+** ^(If the sqlite3_vtab_distinct() interface returns 3, that means
+** that the query planner needs only distinct rows but it does need the
+** rows to be sorted.)^ ^The virtual table implementation is free to omit
+** rows that are identical in all aOrderBy columns, if it wants to, but
+** it is not required to omit any rows. This mode is used for queries
+** that have both DISTINCT and ORDER BY clauses.
**
**
** ^For the purposes of comparing virtual table output values to see if the
diff --git a/src/sqlite3ext.h b/src/sqlite3ext.h
index 2eac4f3f05..a75dd496e7 100644
--- a/src/sqlite3ext.h
+++ b/src/sqlite3ext.h
@@ -351,6 +351,11 @@ struct sqlite3_api_routines {
int (*vtab_in)(sqlite3_index_info*,int,int);
int (*vtab_in_first)(sqlite3_value*,sqlite3_value**);
int (*vtab_in_next)(sqlite3_value*,sqlite3_value**);
+ /* Version 3.39.0 and later */
+ int (*deserialize)(sqlite3*,const char*,unsigned char*,
+ sqlite3_int64,sqlite3_int64,unsigned);
+ unsigned char *(*serialize)(sqlite3*,const char *,sqlite3_int64*,
+ unsigned int);
};
/*
@@ -669,6 +674,10 @@ typedef int (*sqlite3_loadext_entry)(
#define sqlite3_vtab_in sqlite3_api->vtab_in
#define sqlite3_vtab_in_first sqlite3_api->vtab_in_first
#define sqlite3_vtab_in_next sqlite3_api->vtab_in_next
+#ifndef SQLITE_OMIT_DESERIALIZE
+#define sqlite3_deserialize sqlite3_api->deserialize
+#define sqlite3_serialize sqlite3_api->serialize
+#endif
#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index 0f4077aae8..7cbdb46215 100644
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -939,8 +939,19 @@ typedef INT16_TYPE LogEst;
/*
** Round up a number to the next larger multiple of 8. This is used
** to force 8-byte alignment on 64-bit architectures.
+**
+** ROUND8() always does the rounding, for any argument.
+**
+** ROUND8P() assumes that the argument is already an integer number of
+** pointers in size, and so it is a no-op on systems where the pointer
+** size is 8.
*/
#define ROUND8(x) (((x)+7)&~7)
+#if SQLITE_PTRSIZE==8
+# define ROUND8P(x) (x)
+#else
+# define ROUND8P(x) (((x)+7)&~7)
+#endif
/*
** Round down to the nearest multiple of 8
@@ -1003,22 +1014,23 @@ typedef INT16_TYPE LogEst;
#endif
/*
-** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
-** the Select query generator tracing logic is turned on.
+** TREETRACE_ENABLED will be either 1 or 0 depending on whether or not
+** the Abstract Syntax Tree tracing logic is turned on.
*/
#if !defined(SQLITE_AMALGAMATION)
-extern u32 sqlite3SelectTrace;
+extern u32 sqlite3TreeTrace;
#endif
#if defined(SQLITE_DEBUG) \
- && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE))
-# define SELECTTRACE_ENABLED 1
+ && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE) \
+ || defined(SQLITE_ENABLE_TREETRACE))
+# define TREETRACE_ENABLED 1
# define SELECTTRACE(K,P,S,X) \
- if(sqlite3SelectTrace&(K)) \
+ if(sqlite3TreeTrace&(K)) \
sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
sqlite3DebugPrintf X
#else
# define SELECTTRACE(K,P,S,X)
-# define SELECTTRACE_ENABLED 0
+# define TREETRACE_ENABLED 0
#endif
/*
@@ -1179,6 +1191,7 @@ typedef struct Lookaside Lookaside;
typedef struct LookasideSlot LookasideSlot;
typedef struct Module Module;
typedef struct NameContext NameContext;
+typedef struct OnOrUsing OnOrUsing;
typedef struct Parse Parse;
typedef struct ParseCleanup ParseCleanup;
typedef struct PreUpdate PreUpdate;
@@ -1766,6 +1779,9 @@ struct sqlite3 {
#define SQLITE_BloomFilter 0x00080000 /* Use a Bloom filter on searches */
#define SQLITE_BloomPulldown 0x00100000 /* Run Bloom filters early */
#define SQLITE_BalancedMerge 0x00200000 /* Balance multi-way merges */
+#define SQLITE_ReleaseReg 0x00400000 /* Use OP_ReleaseReg for testing */
+#define SQLITE_FlttnUnionAll 0x00800000 /* Disable the UNION ALL flattener */
+ /* TH3 expects this value ^^^^^^^^^^ See flatten04.test */
#define SQLITE_AllOpts 0xffffffff /* All optimizations */
/*
@@ -2111,6 +2127,7 @@ struct Column {
#define COLFLAG_NOTAVAIL 0x0080 /* STORED column not yet calculated */
#define COLFLAG_BUSY 0x0100 /* Blocks recursion on GENERATED columns */
#define COLFLAG_HASCOLL 0x0200 /* Has collating sequence name in zCnName */
+#define COLFLAG_NOEXPAND 0x0400 /* Omit this column when expanding "*" */
#define COLFLAG_GENERATED 0x0060 /* Combo: _STORED, _VIRTUAL */
#define COLFLAG_NOINSERT 0x0062 /* Combo: _HIDDEN, _STORED, _VIRTUAL */
@@ -2830,7 +2847,7 @@ struct Expr {
** TK_SELECT_COLUMN: column of the result vector */
i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
union {
- int iRightJoinTable; /* If EP_FromJoin, the right table of the join */
+ int iJoin; /* If EP_FromJoin, the right table of the join */
int iOfst; /* else: start of token from start of statement */
} w;
AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
@@ -2873,7 +2890,7 @@ struct Expr {
#define EP_ConstFunc 0x080000 /* A SQLITE_FUNC_CONSTANT or _SLOCHNG function */
#define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
#define EP_Subquery 0x200000 /* Tree contains a TK_SELECT operator */
- /* 0x400000 // Available */
+#define EP_InnerJoin 0x400000 /* Originates in ON/USING of an inner join */
#define EP_Leaf 0x800000 /* Expr.pLeft, .pRight, .u.pSelect all NULL */
#define EP_WinFunc 0x1000000 /* TK_FUNCTION with Expr.y.pWin set */
#define EP_Subrtn 0x2000000 /* Uses Expr.y.sub. TK_IN, _SELECT, or _EXISTS */
@@ -2984,12 +3001,18 @@ struct ExprList {
struct ExprList_item { /* For each expression in the list */
Expr *pExpr; /* The parse tree for this expression */
char *zEName; /* Token associated with this expression */
- u8 sortFlags; /* Mask of KEYINFO_ORDER_* flags */
- unsigned eEName :2; /* Meaning of zEName */
- unsigned done :1; /* A flag to indicate when processing is finished */
- unsigned reusable :1; /* Constant expression is reusable */
- unsigned bSorterRef :1; /* Defer evaluation until after sorting */
- unsigned bNulls: 1; /* True if explicit "NULLS FIRST/LAST" */
+ struct {
+ u8 sortFlags; /* Mask of KEYINFO_ORDER_* flags */
+ unsigned eEName :2; /* Meaning of zEName */
+ unsigned done :1; /* Indicates when processing is finished */
+ unsigned reusable :1; /* Constant expression is reusable */
+ unsigned bSorterRef :1; /* Defer evaluation until after sorting */
+ unsigned bNulls :1; /* True if explicit "NULLS FIRST/LAST" */
+ unsigned bUsed :1; /* This column used in a SF_NestedFrom subquery */
+ unsigned bUsingTerm:1; /* Term from the USING clause of a NestedFrom */
+ unsigned bNoExpand: 1; /* Term is an auxiliary in NestedFrom and should
+ ** not be expanded by "*" in parent queries */
+ } fg;
union {
struct { /* Used by any ExprList other than Parse.pConsExpr */
u16 iOrderByCol; /* For ORDER BY, column number in result set */
@@ -3024,13 +3047,25 @@ struct ExprList {
** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
*/
struct IdList {
+ int nId; /* Number of identifiers on the list */
+ u8 eU4; /* Which element of a.u4 is valid */
struct IdList_item {
char *zName; /* Name of the identifier */
- int idx; /* Index in some Table.aCol[] of a column named zName */
- } *a;
- int nId; /* Number of identifiers on the list */
+ union {
+ int idx; /* Index in some Table.aCol[] of a column named zName */
+ Expr *pExpr; /* Expr to implement a USING variable -- NOT USED */
+ } u4;
+ } a[1];
};
+/*
+** Allowed values for IdList.eType, which determines which value of the a.u4
+** is valid.
+*/
+#define EU4_NONE 0 /* Does not use IdList.a.u4 */
+#define EU4_IDX 1 /* Uses IdList.a.u4.idx */
+#define EU4_EXPR 2 /* Uses IdList.a.u4.pExpr -- NOT CURRENTLY USED */
+
/*
** The SrcItem object represents a single term in the FROM clause of a query.
** The SrcList object is mostly an array of SrcItems.
@@ -3063,10 +3098,15 @@ struct SrcItem {
unsigned fromDDL :1; /* Comes from sqlite_schema */
unsigned isCte :1; /* This is a CTE */
unsigned notCte :1; /* This item may not match a CTE */
+ unsigned isUsing :1; /* u3.pUsing is valid */
+ unsigned isSynthUsing :1; /* u3.pUsing is synthensized from NATURAL */
+ unsigned isNestedFrom :1; /* pSelect is a SF_NestedFrom subquery */
} fg;
int iCursor; /* The VDBE cursor number used to access this table */
- Expr *pOn; /* The ON clause of a join */
- IdList *pUsing; /* The USING clause of a join */
+ union {
+ Expr *pOn; /* fg.isUsing==0 => The ON clause of a join */
+ IdList *pUsing; /* fg.isUsing==1 => The USING clause of a join */
+ } u3;
Bitmask colUsed; /* Bit N (1<" clause */
@@ -3078,6 +3118,15 @@ struct SrcItem {
} u2;
};
+/*
+** The OnOrUsing object represents either an ON clause or a USING clause.
+** It can never be both at the same time, but it can be neither.
+*/
+struct OnOrUsing {
+ Expr *pOn; /* The ON clause of a join */
+ IdList *pUsing; /* The USING clause of a join */
+};
+
/*
** The following structure describes the FROM clause of a SELECT statement.
** Each table or subquery in the FROM clause is a separate element of
@@ -3106,14 +3155,15 @@ struct SrcList {
/*
** Permitted values of the SrcList.a.jointype field
*/
-#define JT_INNER 0x0001 /* Any kind of inner or cross join */
-#define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
-#define JT_NATURAL 0x0004 /* True for a "natural" join */
-#define JT_LEFT 0x0008 /* Left outer join */
-#define JT_RIGHT 0x0010 /* Right outer join */
-#define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
-#define JT_ERROR 0x0040 /* unknown or unsupported join type */
-
+#define JT_INNER 0x01 /* Any kind of inner or cross join */
+#define JT_CROSS 0x02 /* Explicit use of the CROSS keyword */
+#define JT_NATURAL 0x04 /* True for a "natural" join */
+#define JT_LEFT 0x08 /* Left outer join */
+#define JT_RIGHT 0x10 /* Right outer join */
+#define JT_OUTER 0x20 /* The "OUTER" keyword is present */
+#define JT_LTORJ 0x40 /* One of the LEFT operands of a RIGHT JOIN
+ ** Mnemonic: Left Table Of Right Join */
+#define JT_ERROR 0x80 /* unknown or unsupported join type */
/*
** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
@@ -3136,7 +3186,7 @@ struct SrcList {
#define WHERE_SORTBYGROUP 0x0200 /* Support sqlite3WhereIsSorted() */
#define WHERE_AGG_DISTINCT 0x0400 /* Query is "SELECT agg(DISTINCT ...)" */
#define WHERE_ORDERBY_LIMIT 0x0800 /* ORDERBY+LIMIT on the inner loop */
- /* 0x1000 not currently used */
+#define WHERE_RIGHT_JOIN 0x1000 /* Processing a RIGHT JOIN */
/* 0x2000 not currently used */
#define WHERE_USE_LIMIT 0x4000 /* Use the LIMIT in cost estimates */
/* 0x8000 not currently used */
@@ -3332,6 +3382,9 @@ struct Select {
#define SF_CopyCte 0x4000000 /* SELECT statement is a copy of a CTE */
#define SF_OrderByReqd 0x8000000 /* The ORDER BY clause may not be omitted */
+/* True if S exists and has SF_NestedFrom */
+#define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0)
+
/*
** The results of a SELECT can be distributed in several ways, as defined
** by one of the following macros. The "SRT" prefix means "SELECT Result
@@ -3543,6 +3596,7 @@ struct Parse {
u8 okConstFactor; /* OK to factor out constants */
u8 disableLookaside; /* Number of times lookaside has been disabled */
u8 disableVtab; /* Disable all virtual tables for this parse */
+ u8 withinRJSubrtn; /* Nesting level for RIGHT JOIN body subroutines */
#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
u8 earlyCleanup; /* OOM inside sqlite3ParserAddCleanup() */
#endif
@@ -3715,20 +3769,20 @@ struct AuthContext {
#define OPFLAG_PREFORMAT 0x80 /* OP_Insert uses preformatted cell */
/*
- * Each trigger present in the database schema is stored as an instance of
- * struct Trigger.
- *
- * Pointers to instances of struct Trigger are stored in two ways.
- * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
- * database). This allows Trigger structures to be retrieved by name.
- * 2. All triggers associated with a single table form a linked list, using the
- * pNext member of struct Trigger. A pointer to the first element of the
- * linked list is stored as the "pTrigger" member of the associated
- * struct Table.
- *
- * The "step_list" member points to the first element of a linked list
- * containing the SQL statements specified as the trigger program.
- */
+** Each trigger present in the database schema is stored as an instance of
+** struct Trigger.
+**
+** Pointers to instances of struct Trigger are stored in two ways.
+** 1. In the "trigHash" hash table (part of the sqlite3* that represents the
+** database). This allows Trigger structures to be retrieved by name.
+** 2. All triggers associated with a single table form a linked list, using the
+** pNext member of struct Trigger. A pointer to the first element of the
+** linked list is stored as the "pTrigger" member of the associated
+** struct Table.
+**
+** The "step_list" member points to the first element of a linked list
+** containing the SQL statements specified as the trigger program.
+*/
struct Trigger {
char *zName; /* The name of the trigger */
char *table; /* The table or view to which the trigger applies */
@@ -3755,43 +3809,48 @@ struct Trigger {
#define TRIGGER_AFTER 2
/*
- * An instance of struct TriggerStep is used to store a single SQL statement
- * that is a part of a trigger-program.
- *
- * Instances of struct TriggerStep are stored in a singly linked list (linked
- * using the "pNext" member) referenced by the "step_list" member of the
- * associated struct Trigger instance. The first element of the linked list is
- * the first step of the trigger-program.
- *
- * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
- * "SELECT" statement. The meanings of the other members is determined by the
- * value of "op" as follows:
- *
- * (op == TK_INSERT)
- * orconf -> stores the ON CONFLICT algorithm
- * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
- * this stores a pointer to the SELECT statement. Otherwise NULL.
- * zTarget -> Dequoted name of the table to insert into.
- * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
- * this stores values to be inserted. Otherwise NULL.
- * pIdList -> If this is an INSERT INTO ... () VALUES ...
- * statement, then this stores the column-names to be
- * inserted into.
- *
- * (op == TK_DELETE)
- * zTarget -> Dequoted name of the table to delete from.
- * pWhere -> The WHERE clause of the DELETE statement if one is specified.
- * Otherwise NULL.
- *
- * (op == TK_UPDATE)
- * zTarget -> Dequoted name of the table to update.
- * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
- * Otherwise NULL.
- * pExprList -> A list of the columns to update and the expressions to update
- * them to. See sqlite3Update() documentation of "pChanges"
- * argument.
- *
- */
+** An instance of struct TriggerStep is used to store a single SQL statement
+** that is a part of a trigger-program.
+**
+** Instances of struct TriggerStep are stored in a singly linked list (linked
+** using the "pNext" member) referenced by the "step_list" member of the
+** associated struct Trigger instance. The first element of the linked list is
+** the first step of the trigger-program.
+**
+** The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
+** "SELECT" statement. The meanings of the other members is determined by the
+** value of "op" as follows:
+**
+** (op == TK_INSERT)
+** orconf -> stores the ON CONFLICT algorithm
+** pSelect -> The content to be inserted - either a SELECT statement or
+** a VALUES clause.
+** zTarget -> Dequoted name of the table to insert into.
+** pIdList -> If this is an INSERT INTO ... () VALUES ...
+** statement, then this stores the column-names to be
+** inserted into.
+** pUpsert -> The ON CONFLICT clauses for an Upsert
+**
+** (op == TK_DELETE)
+** zTarget -> Dequoted name of the table to delete from.
+** pWhere -> The WHERE clause of the DELETE statement if one is specified.
+** Otherwise NULL.
+**
+** (op == TK_UPDATE)
+** zTarget -> Dequoted name of the table to update.
+** pWhere -> The WHERE clause of the UPDATE statement if one is specified.
+** Otherwise NULL.
+** pExprList -> A list of the columns to update and the expressions to update
+** them to. See sqlite3Update() documentation of "pChanges"
+** argument.
+**
+** (op == TK_SELECT)
+** pSelect -> The SELECT statement
+**
+** (op == TK_RETURNING)
+** pExprList -> The list of expressions that follow the RETURNING keyword.
+**
+*/
struct TriggerStep {
u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT,
** or TK_RETURNING */
@@ -4401,18 +4460,51 @@ char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
#endif
#if defined(SQLITE_DEBUG)
+ void sqlite3TreeViewLine(TreeView*, const char *zFormat, ...);
void sqlite3TreeViewExpr(TreeView*, const Expr*, u8);
void sqlite3TreeViewBareExprList(TreeView*, const ExprList*, const char*);
void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*);
+ void sqlite3TreeViewBareIdList(TreeView*, const IdList*, const char*);
+ void sqlite3TreeViewIdList(TreeView*, const IdList*, u8, const char*);
+ void sqlite3TreeViewColumnList(TreeView*, const Column*, int, u8);
void sqlite3TreeViewSrcList(TreeView*, const SrcList*);
void sqlite3TreeViewSelect(TreeView*, const Select*, u8);
void sqlite3TreeViewWith(TreeView*, const With*, u8);
+ void sqlite3TreeViewUpsert(TreeView*, const Upsert*, u8);
+ void sqlite3TreeViewDelete(const With*, const SrcList*, const Expr*,
+ const ExprList*,const Expr*, const Trigger*);
+ void sqlite3TreeViewInsert(const With*, const SrcList*,
+ const IdList*, const Select*, const ExprList*,
+ int, const Upsert*, const Trigger*);
+ void sqlite3TreeViewUpdate(const With*, const SrcList*, const ExprList*,
+ const Expr*, int, const ExprList*, const Expr*,
+ const Upsert*, const Trigger*);
+#ifndef SQLITE_OMIT_TRIGGER
+ void sqlite3TreeViewTriggerStep(TreeView*, const TriggerStep*, u8, u8);
+ void sqlite3TreeViewTrigger(TreeView*, const Trigger*, u8, u8);
+#endif
#ifndef SQLITE_OMIT_WINDOWFUNC
void sqlite3TreeViewWindow(TreeView*, const Window*, u8);
void sqlite3TreeViewWinFunc(TreeView*, const Window*, u8);
+#endif
+ void sqlite3ShowExpr(const Expr*);
+ void sqlite3ShowExprList(const ExprList*);
+ void sqlite3ShowIdList(const IdList*);
+ void sqlite3ShowSrcList(const SrcList*);
+ void sqlite3ShowSelect(const Select*);
+ void sqlite3ShowWith(const With*);
+ void sqlite3ShowUpsert(const Upsert*);
+#ifndef SQLITE_OMIT_TRIGGER
+ void sqlite3ShowTriggerStep(const TriggerStep*);
+ void sqlite3ShowTriggerStepList(const TriggerStep*);
+ void sqlite3ShowTrigger(const Trigger*);
+ void sqlite3ShowTriggerList(const Trigger*);
+#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC
+ void sqlite3ShowWindow(const Window*);
+ void sqlite3ShowWinFunc(const Window*);
#endif
#endif
-
void sqlite3SetString(char **, sqlite3*, const char*);
void sqlite3ErrorMsg(Parse*, const char*, ...);
@@ -4561,13 +4653,14 @@ SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int);
SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2);
SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*);
SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
- Token*, Select*, Expr*, IdList*);
+ Token*, Select*, OnOrUsing*);
void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*);
int sqlite3IndexedByLookup(Parse *, SrcItem *);
-void sqlite3SrcListShiftJoinType(SrcList*);
+void sqlite3SrcListShiftJoinType(Parse*,SrcList*);
void sqlite3SrcListAssignCursors(Parse*, SrcList*);
void sqlite3IdListDelete(sqlite3*, IdList*);
+void sqlite3ClearOnOrUsing(sqlite3*, OnOrUsing*);
void sqlite3SrcListDelete(sqlite3*, SrcList*);
Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**);
void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
@@ -4667,6 +4760,7 @@ int sqlite3ExprIsConstantNotJoin(Expr*);
int sqlite3ExprIsConstantOrFunction(Expr*, u8);
int sqlite3ExprIsConstantOrGroupBy(Parse*, Expr*, ExprList*);
int sqlite3ExprIsTableConstant(Expr*,int);
+int sqlite3ExprIsTableConstraint(Expr*,const SrcItem*);
#ifdef SQLITE_ENABLE_CURSOR_HINTS
int sqlite3ExprContainsSubquery(Expr*);
#endif
@@ -4764,7 +4858,8 @@ void sqlite3MaterializeView(Parse*, Table*, Expr*, ExprList*,Expr*,int);
int sqlite3JoinType(Parse*, Token*, Token*, Token*);
int sqlite3ColumnIndex(Table *pTab, const char *zCol);
-void sqlite3SetJoinExpr(Expr*,int);
+void sqlite3SrcItemColumnUsed(SrcItem*,int);
+void sqlite3SetJoinExpr(Expr*,int,u32);
void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
void sqlite3DeferForeignKey(Parse*, int);
#ifndef SQLITE_OMIT_AUTHORIZATION
@@ -5110,7 +5205,7 @@ int sqlite3VtabBegin(sqlite3 *, VTable *);
FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
#if (defined(SQLITE_ENABLE_DBPAGE_VTAB) || defined(SQLITE_TEST)) \
&& !defined(SQLITE_OMIT_VIRTUALTABLE)
- void sqlite3VtabWriteAll(sqlite3_index_info*);
+ void sqlite3VtabUsesAllSchemas(sqlite3_index_info*);
#endif
sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
@@ -5227,6 +5322,7 @@ const char *sqlite3JournalModename(int);
#define IN_INDEX_NOOP_OK 0x0001 /* OK to return IN_INDEX_NOOP */
#define IN_INDEX_MEMBERSHIP 0x0002 /* IN operator used for membership test */
#define IN_INDEX_LOOP 0x0004 /* IN operator used as a loop */
+#define IN_INDEX_REUSE_CUR 0x0008 /* Reuse prior table cursor */
int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*, int*);
int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
diff --git a/src/status.c b/src/status.c
index f0e307c2dd..e7f2158446 100644
--- a/src/status.c
+++ b/src/status.c
@@ -334,8 +334,7 @@ int sqlite3_db_status(
db->pnBytesFreed = &nByte;
for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
- sqlite3VdbeClearObject(db, pVdbe);
- sqlite3DbFree(db, pVdbe);
+ sqlite3VdbeDelete(pVdbe);
}
db->pnBytesFreed = 0;
diff --git a/src/test1.c b/src/test1.c
index 455c4b2579..6ccd4512f5 100644
--- a/src/test1.c
+++ b/src/test1.c
@@ -8908,9 +8908,9 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
(char*)&sqlite3_sync_count, TCL_LINK_INT);
Tcl_LinkVar(interp, "sqlite_fullsync_count",
(char*)&sqlite3_fullsync_count, TCL_LINK_INT);
-#if defined(SQLITE_ENABLE_SELECTTRACE)
- Tcl_LinkVar(interp, "sqlite3_unsupported_selecttrace",
- (char*)&sqlite3SelectTrace, TCL_LINK_INT);
+#if defined(SQLITE_ENABLE_TREETRACE)
+ Tcl_LinkVar(interp, "sqlite3_unsupported_treetrace",
+ (char*)&sqlite3TreeTrace, TCL_LINK_INT);
#endif
#if defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_TEST)
Tcl_LinkVar(interp, "sqlite_fts3_enable_parentheses",
diff --git a/src/tokenize.c b/src/tokenize.c
index a727078ba7..f0c0cc1910 100644
--- a/src/tokenize.c
+++ b/src/tokenize.c
@@ -710,7 +710,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql){
if( pParse->pNewTrigger && !IN_RENAME_OBJECT ){
sqlite3DeleteTrigger(db, pParse->pNewTrigger);
}
- sqlite3DbFree(db, pParse->pVList);
+ if( pParse->pVList ) sqlite3DbFreeNN(db, pParse->pVList);
db->pParse = pParentParse;
assert( nErr==0 || pParse->rc!=SQLITE_OK );
return nErr;
diff --git a/src/treeview.c b/src/treeview.c
index b547c96c57..3ff300c38b 100644
--- a/src/treeview.c
+++ b/src/treeview.c
@@ -24,33 +24,37 @@
** Add a new subitem to the tree. The moreToFollow flag indicates that this
** is not the last item in the tree.
*/
-static TreeView *sqlite3TreeViewPush(TreeView *p, u8 moreToFollow){
+static void sqlite3TreeViewPush(TreeView **pp, u8 moreToFollow){
+ TreeView *p = *pp;
if( p==0 ){
- p = sqlite3_malloc64( sizeof(*p) );
- if( p==0 ) return 0;
+ *pp = p = sqlite3_malloc64( sizeof(*p) );
+ if( p==0 ) return;
memset(p, 0, sizeof(*p));
}else{
p->iLevel++;
}
assert( moreToFollow==0 || moreToFollow==1 );
if( p->iLevel<(int)sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow;
- return p;
}
/*
** Finished with one layer of the tree
*/
-static void sqlite3TreeViewPop(TreeView *p){
+static void sqlite3TreeViewPop(TreeView **pp){
+ TreeView *p = *pp;
if( p==0 ) return;
p->iLevel--;
- if( p->iLevel<0 ) sqlite3_free(p);
+ if( p->iLevel<0 ){
+ sqlite3_free(p);
+ *pp = 0;
+ }
}
/*
** Generate a single line of output for the tree, with a prefix that contains
** all the appropriate tree lines
*/
-static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
+void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
va_list ap;
int i;
StrAccum acc;
@@ -78,10 +82,57 @@ static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
** Shorthand for starting a new tree item that consists of a single label
*/
static void sqlite3TreeViewItem(TreeView *p, const char *zLabel,u8 moreFollows){
- p = sqlite3TreeViewPush(p, moreFollows);
+ sqlite3TreeViewPush(&p, moreFollows);
sqlite3TreeViewLine(p, "%s", zLabel);
}
+/*
+** Show a list of Column objects in tree format.
+*/
+void sqlite3TreeViewColumnList(
+ TreeView *pView,
+ const Column *aCol,
+ int nCol,
+ u8 moreToFollow
+){
+ int i;
+ sqlite3TreeViewPush(&pView, moreToFollow);
+ sqlite3TreeViewLine(pView, "COLUMNS");
+ for(i=0; inCte>0 ){
- pView = sqlite3TreeViewPush(pView, 1);
+ sqlite3TreeViewPush(&pView, moreToFollow);
for(i=0; inCte; i++){
StrAccum x;
char zLine[1000];
@@ -111,6 +162,10 @@ void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){
}
sqlite3_str_appendf(&x, ")");
}
+ if( pCte->eM10d!=M10d_Any ){
+ sqlite3_str_appendf(&x, " %sMATERIALIZED",
+ pCte->eM10d==M10d_No ? "NOT " : "");
+ }
if( pCte->pUse ){
sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse,
pCte->pUse->nUse);
@@ -118,9 +173,9 @@ void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){
sqlite3StrAccumFinish(&x);
sqlite3TreeViewItem(pView, zLine, inCte-1);
sqlite3TreeViewSelect(pView, pCte->pSelect, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
}
@@ -129,9 +184,11 @@ void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){
*/
void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
int i;
+ if( pSrc==0 ) return;
for(i=0; inSrc; i++){
const SrcItem *pItem = &pSrc->a[i];
StrAccum x;
+ int n = 0;
char zLine[100];
sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
x.printfFlags |= SQLITE_PRINTF_INTERNAL;
@@ -140,11 +197,18 @@ void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
}
- if( pItem->fg.jointype & JT_LEFT ){
+ if( (pItem->fg.jointype & (JT_LEFT|JT_RIGHT))==(JT_LEFT|JT_RIGHT) ){
+ sqlite3_str_appendf(&x, " FULL-OUTER-JOIN");
+ }else if( pItem->fg.jointype & JT_LEFT ){
sqlite3_str_appendf(&x, " LEFT-JOIN");
+ }else if( pItem->fg.jointype & JT_RIGHT ){
+ sqlite3_str_appendf(&x, " RIGHT-JOIN");
}else if( pItem->fg.jointype & JT_CROSS ){
sqlite3_str_appendf(&x, " CROSS-JOIN");
}
+ if( pItem->fg.jointype & JT_LTORJ ){
+ sqlite3_str_appendf(&x, " LTORJ");
+ }
if( pItem->fg.fromDDL ){
sqlite3_str_appendf(&x, " DDL");
}
@@ -152,14 +216,26 @@ void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse);
}
sqlite3StrAccumFinish(&x);
- sqlite3TreeViewItem(pView, zLine, inSrc-1);
+ sqlite3TreeViewItem(pView, zLine, inSrc-1);
+ n = 0;
+ if( pItem->pSelect ) n++;
+ if( pItem->fg.isTabFunc ) n++;
+ if( pItem->fg.isUsing ) n++;
+ if( pItem->fg.isUsing ){
+ sqlite3TreeViewIdList(pView, pItem->u3.pUsing, (--n)>0, "USING");
+ }
if( pItem->pSelect ){
- sqlite3TreeViewSelect(pView, pItem->pSelect, 0);
+ if( pItem->pTab ){
+ Table *pTab = pItem->pTab;
+ sqlite3TreeViewColumnList(pView, pTab->aCol, pTab->nCol, 1);
+ }
+ assert( pItem->fg.isNestedFrom == IsNestedFrom(pItem->pSelect) );
+ sqlite3TreeViewSelect(pView, pItem->pSelect, (--n)>0);
}
if( pItem->fg.isTabFunc ){
sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:");
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
}
@@ -173,11 +249,11 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
sqlite3TreeViewLine(pView, "nil-SELECT");
return;
}
- pView = sqlite3TreeViewPush(pView, moreToFollow);
+ sqlite3TreeViewPush(&pView, moreToFollow);
if( p->pWith ){
sqlite3TreeViewWith(pView, p->pWith, 1);
cnt = 1;
- sqlite3TreeViewPush(pView, 1);
+ sqlite3TreeViewPush(&pView, 1);
}
do{
if( p->selFlags & SF_WhereBegin ){
@@ -191,7 +267,7 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
(int)p->nSelectRow
);
}
- if( cnt++ ) sqlite3TreeViewPop(pView);
+ if( cnt++ ) sqlite3TreeViewPop(&pView);
if( p->pPrior ){
n = 1000;
}else{
@@ -214,24 +290,24 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
#ifndef SQLITE_OMIT_WINDOWFUNC
if( p->pWin ){
Window *pX;
- pView = sqlite3TreeViewPush(pView, (n--)>0);
+ sqlite3TreeViewPush(&pView, (n--)>0);
sqlite3TreeViewLine(pView, "window-functions");
for(pX=p->pWin; pX; pX=pX->pNextWin){
sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0);
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
#endif
if( p->pSrc && p->pSrc->nSrc ){
- pView = sqlite3TreeViewPush(pView, (n--)>0);
+ sqlite3TreeViewPush(&pView, (n--)>0);
sqlite3TreeViewLine(pView, "FROM");
sqlite3TreeViewSrcList(pView, p->pSrc);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
if( p->pWhere ){
sqlite3TreeViewItem(pView, "WHERE", (n--)>0);
sqlite3TreeViewExpr(pView, p->pWhere, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
if( p->pGroupBy ){
sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0, "GROUPBY");
@@ -239,7 +315,7 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
if( p->pHaving ){
sqlite3TreeViewItem(pView, "HAVING", (n--)>0);
sqlite3TreeViewExpr(pView, p->pHaving, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
#ifndef SQLITE_OMIT_WINDOWFUNC
if( p->pWinDefn ){
@@ -248,7 +324,7 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
for(pX=p->pWinDefn; pX; pX=pX->pNextWin){
sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0);
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
#endif
if( p->pOrderBy ){
@@ -260,9 +336,9 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
if( p->pLimit->pRight ){
sqlite3TreeViewItem(pView, "OFFSET", (n--)>0);
sqlite3TreeViewExpr(pView, p->pLimit->pRight, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
if( p->pPrior ){
const char *zOp = "UNION";
@@ -275,7 +351,7 @@ void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
}
p = p->pPrior;
}while( p!=0 );
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
#ifndef SQLITE_OMIT_WINDOWFUNC
@@ -291,24 +367,24 @@ void sqlite3TreeViewBound(
switch( eBound ){
case TK_UNBOUNDED: {
sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
break;
}
case TK_CURRENT: {
sqlite3TreeViewItem(pView, "CURRENT", moreToFollow);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
break;
}
case TK_PRECEDING: {
sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow);
sqlite3TreeViewExpr(pView, pExpr, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
break;
}
case TK_FOLLOWING: {
sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow);
sqlite3TreeViewExpr(pView, pExpr, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
break;
}
}
@@ -321,12 +397,13 @@ void sqlite3TreeViewBound(
*/
void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
int nElement = 0;
+ if( pWin==0 ) return;
if( pWin->pFilter ){
sqlite3TreeViewItem(pView, "FILTER", 1);
sqlite3TreeViewExpr(pView, pWin->pFilter, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
- pView = sqlite3TreeViewPush(pView, more);
+ sqlite3TreeViewPush(&pView, more);
if( pWin->zName ){
sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
}else{
@@ -337,9 +414,9 @@ void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
if( pWin->eFrmType ) nElement++;
if( pWin->eExclude ) nElement++;
if( pWin->zBase ){
- sqlite3TreeViewPush(pView, (--nElement)>0);
+ sqlite3TreeViewPush(&pView, (--nElement)>0);
sqlite3TreeViewLine(pView, "window: %s", pWin->zBase);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
if( pWin->pPartition ){
sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY");
@@ -357,7 +434,7 @@ void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
sqlite3TreeViewItem(pView, zBuf, (--nElement)>0);
sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1);
sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
if( pWin->eExclude ){
char zBuf[30];
@@ -372,11 +449,11 @@ void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
zExclude = zBuf;
break;
}
- sqlite3TreeViewPush(pView, 0);
+ sqlite3TreeViewPush(&pView, 0);
sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
#endif /* SQLITE_OMIT_WINDOWFUNC */
@@ -385,11 +462,12 @@ void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
** Generate a human-readable explanation for a Window Function object
*/
void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){
- pView = sqlite3TreeViewPush(pView, more);
+ if( pWin==0 ) return;
+ sqlite3TreeViewPush(&pView, more);
sqlite3TreeViewLine(pView, "WINFUNC %s(%d)",
pWin->pWFunc->zName, pWin->pWFunc->nArg);
sqlite3TreeViewWindow(pView, pWin, 0);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
#endif /* SQLITE_OMIT_WINDOWFUNC */
@@ -400,10 +478,10 @@ void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
const char *zBinOp = 0; /* Binary operator */
const char *zUniOp = 0; /* Unary operator */
char zFlgs[200];
- pView = sqlite3TreeViewPush(pView, moreToFollow);
+ sqlite3TreeViewPush(&pView, moreToFollow);
if( pExpr==0 ){
sqlite3TreeViewLine(pView, "nil");
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
return;
}
if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){
@@ -412,7 +490,7 @@ void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
sqlite3_str_appendf(&x, " fg.af=%x.%c",
pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
if( ExprHasProperty(pExpr, EP_FromJoin) ){
- sqlite3_str_appendf(&x, " iRJT=%d", pExpr->w.iRightJoinTable);
+ sqlite3_str_appendf(&x, " iJoin=%d", pExpr->w.iJoin);
}
if( ExprHasProperty(pExpr, EP_FromDDL) ){
sqlite3_str_appendf(&x, " DDL");
@@ -636,7 +714,17 @@ void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
break;
}
case TK_IN: {
- sqlite3TreeViewLine(pView, "IN flags=0x%x", pExpr->flags);
+ sqlite3_str *pStr = sqlite3_str_new(0);
+ char *z;
+ sqlite3_str_appendf(pStr, "IN flags=0x%x", pExpr->flags);
+ if( pExpr->iTable ) sqlite3_str_appendf(pStr, " iTable=%d",pExpr->iTable);
+ if( ExprHasProperty(pExpr, EP_Subrtn) ){
+ sqlite3_str_appendf(pStr, " subrtn(%d,%d)",
+ pExpr->y.sub.regReturn, pExpr->y.sub.iAddr);
+ }
+ z = sqlite3_str_finish(pStr);
+ sqlite3TreeViewLine(pView, z);
+ sqlite3_free(z);
sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
if( ExprUseXSelect(pExpr) ){
sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
@@ -760,7 +848,7 @@ void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
sqlite3TreeViewLine(pView, "%s%s", zUniOp, zFlgs);
sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
}
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
@@ -782,13 +870,25 @@ void sqlite3TreeViewBareExprList(
int j = pList->a[i].u.x.iOrderByCol;
char *zName = pList->a[i].zEName;
int moreToFollow = inExpr - 1;
- if( pList->a[i].eEName!=ENAME_NAME ) zName = 0;
if( j || zName ){
- sqlite3TreeViewPush(pView, moreToFollow);
+ sqlite3TreeViewPush(&pView, moreToFollow);
moreToFollow = 0;
sqlite3TreeViewLine(pView, 0);
if( zName ){
- fprintf(stdout, "AS %s ", zName);
+ switch( pList->a[i].fg.eEName ){
+ default:
+ fprintf(stdout, "AS %s ", zName);
+ break;
+ case ENAME_TAB:
+ fprintf(stdout, "TABLE-ALIAS-NAME(\"%s\") ", zName);
+ if( pList->a[i].fg.bUsed ) fprintf(stdout, "(used) ");
+ if( pList->a[i].fg.bUsingTerm ) fprintf(stdout, "(USING-term) ");
+ if( pList->a[i].fg.bNoExpand ) fprintf(stdout, "(NoExpand) ");
+ break;
+ case ENAME_SPAN:
+ fprintf(stdout, "SPAN(\"%s\") ", zName);
+ break;
+ }
}
if( j ){
fprintf(stdout, "iOrderByCol=%d", j);
@@ -798,7 +898,7 @@ void sqlite3TreeViewBareExprList(
}
sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
if( j || zName ){
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
}
}
@@ -809,9 +909,370 @@ void sqlite3TreeViewExprList(
u8 moreToFollow,
const char *zLabel
){
- pView = sqlite3TreeViewPush(pView, moreToFollow);
+ sqlite3TreeViewPush(&pView, moreToFollow);
sqlite3TreeViewBareExprList(pView, pList, zLabel);
- sqlite3TreeViewPop(pView);
+ sqlite3TreeViewPop(&pView);
}
+/*
+** Generate a human-readable explanation of an id-list.
+*/
+void sqlite3TreeViewBareIdList(
+ TreeView *pView,
+ const IdList *pList,
+ const char *zLabel
+){
+ if( zLabel==0 || zLabel[0]==0 ) zLabel = "LIST";
+ if( pList==0 ){
+ sqlite3TreeViewLine(pView, "%s (empty)", zLabel);
+ }else{
+ int i;
+ sqlite3TreeViewLine(pView, "%s", zLabel);
+ for(i=0; inId; i++){
+ char *zName = pList->a[i].zName;
+ int moreToFollow = inId - 1;
+ if( zName==0 ) zName = "(null)";
+ sqlite3TreeViewPush(&pView, moreToFollow);
+ sqlite3TreeViewLine(pView, 0);
+ if( pList->eU4==EU4_NONE ){
+ fprintf(stdout, "%s\n", zName);
+ }else if( pList->eU4==EU4_IDX ){
+ fprintf(stdout, "%s (%d)\n", zName, pList->a[i].u4.idx);
+ }else{
+ assert( pList->eU4==EU4_EXPR );
+ if( pList->a[i].u4.pExpr==0 ){
+ fprintf(stdout, "%s (pExpr=NULL)\n", zName);
+ }else{
+ fprintf(stdout, "%s\n", zName);
+ sqlite3TreeViewPush(&pView, inId-1);
+ sqlite3TreeViewExpr(pView, pList->a[i].u4.pExpr, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ }
+ sqlite3TreeViewPop(&pView);
+ }
+ }
+}
+void sqlite3TreeViewIdList(
+ TreeView *pView,
+ const IdList *pList,
+ u8 moreToFollow,
+ const char *zLabel
+){
+ sqlite3TreeViewPush(&pView, moreToFollow);
+ sqlite3TreeViewBareIdList(pView, pList, zLabel);
+ sqlite3TreeViewPop(&pView);
+}
+
+/*
+** Generate a human-readable explanation of a list of Upsert objects
+*/
+void sqlite3TreeViewUpsert(
+ TreeView *pView,
+ const Upsert *pUpsert,
+ u8 moreToFollow
+){
+ if( pUpsert==0 ) return;
+ sqlite3TreeViewPush(&pView, moreToFollow);
+ while( pUpsert ){
+ int n;
+ sqlite3TreeViewPush(&pView, pUpsert->pNextUpsert!=0 || moreToFollow);
+ sqlite3TreeViewLine(pView, "ON CONFLICT DO %s",
+ pUpsert->isDoUpdate ? "UPDATE" : "NOTHING");
+ n = (pUpsert->pUpsertSet!=0) + (pUpsert->pUpsertWhere!=0);
+ sqlite3TreeViewExprList(pView, pUpsert->pUpsertTarget, (n--)>0, "TARGET");
+ sqlite3TreeViewExprList(pView, pUpsert->pUpsertSet, (n--)>0, "SET");
+ if( pUpsert->pUpsertWhere ){
+ sqlite3TreeViewItem(pView, "WHERE", (n--)>0);
+ sqlite3TreeViewExpr(pView, pUpsert->pUpsertWhere, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ sqlite3TreeViewPop(&pView);
+ pUpsert = pUpsert->pNextUpsert;
+ }
+ sqlite3TreeViewPop(&pView);
+}
+
+/*
+** Generate a human-readable diagram of the data structure that go
+** into generating an DELETE statement.
+*/
+void sqlite3TreeViewDelete(
+ const With *pWith,
+ const SrcList *pTabList,
+ const Expr *pWhere,
+ const ExprList *pOrderBy,
+ const Expr *pLimit,
+ const Trigger *pTrigger
+){
+ int n = 0;
+ TreeView *pView = 0;
+ sqlite3TreeViewPush(&pView, 0);
+ sqlite3TreeViewLine(pView, "DELETE");
+ if( pWith ) n++;
+ if( pTabList ) n++;
+ if( pWhere ) n++;
+ if( pOrderBy ) n++;
+ if( pLimit ) n++;
+ if( pTrigger ) n++;
+ if( pWith ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewWith(pView, pWith, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pTabList ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "FROM");
+ sqlite3TreeViewSrcList(pView, pTabList);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pWhere ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "WHERE");
+ sqlite3TreeViewExpr(pView, pWhere, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pOrderBy ){
+ sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY");
+ }
+ if( pLimit ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "LIMIT");
+ sqlite3TreeViewExpr(pView, pLimit, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pTrigger ){
+ sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1);
+ }
+ sqlite3TreeViewPop(&pView);
+}
+
+/*
+** Generate a human-readable diagram of the data structure that go
+** into generating an INSERT statement.
+*/
+void sqlite3TreeViewInsert(
+ const With *pWith,
+ const SrcList *pTabList,
+ const IdList *pColumnList,
+ const Select *pSelect,
+ const ExprList *pExprList,
+ int onError,
+ const Upsert *pUpsert,
+ const Trigger *pTrigger
+){
+ TreeView *pView = 0;
+ int n = 0;
+ const char *zLabel = "INSERT";
+ switch( onError ){
+ case OE_Replace: zLabel = "REPLACE"; break;
+ case OE_Ignore: zLabel = "INSERT OR IGNORE"; break;
+ case OE_Rollback: zLabel = "INSERT OR ROLLBACK"; break;
+ case OE_Abort: zLabel = "INSERT OR ABORT"; break;
+ case OE_Fail: zLabel = "INSERT OR FAIL"; break;
+ }
+ sqlite3TreeViewPush(&pView, 0);
+ sqlite3TreeViewLine(pView, zLabel);
+ if( pWith ) n++;
+ if( pTabList ) n++;
+ if( pColumnList ) n++;
+ if( pSelect ) n++;
+ if( pExprList ) n++;
+ if( pUpsert ) n++;
+ if( pTrigger ) n++;
+ if( pWith ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewWith(pView, pWith, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pTabList ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "INTO");
+ sqlite3TreeViewSrcList(pView, pTabList);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pColumnList ){
+ sqlite3TreeViewIdList(pView, pColumnList, (--n)>0, "COLUMNS");
+ }
+ if( pSelect ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "DATA-SOURCE");
+ sqlite3TreeViewSelect(pView, pSelect, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pExprList ){
+ sqlite3TreeViewExprList(pView, pExprList, (--n)>0, "VALUES");
+ }
+ if( pUpsert ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "UPSERT");
+ sqlite3TreeViewUpsert(pView, pUpsert, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pTrigger ){
+ sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1);
+ }
+ sqlite3TreeViewPop(&pView);
+}
+
+/*
+** Generate a human-readable diagram of the data structure that go
+** into generating an UPDATE statement.
+*/
+void sqlite3TreeViewUpdate(
+ const With *pWith,
+ const SrcList *pTabList,
+ const ExprList *pChanges,
+ const Expr *pWhere,
+ int onError,
+ const ExprList *pOrderBy,
+ const Expr *pLimit,
+ const Upsert *pUpsert,
+ const Trigger *pTrigger
+){
+ int n = 0;
+ TreeView *pView = 0;
+ const char *zLabel = "UPDATE";
+ switch( onError ){
+ case OE_Replace: zLabel = "UPDATE OR REPLACE"; break;
+ case OE_Ignore: zLabel = "UPDATE OR IGNORE"; break;
+ case OE_Rollback: zLabel = "UPDATE OR ROLLBACK"; break;
+ case OE_Abort: zLabel = "UPDATE OR ABORT"; break;
+ case OE_Fail: zLabel = "UPDATE OR FAIL"; break;
+ }
+ sqlite3TreeViewPush(&pView, 0);
+ sqlite3TreeViewLine(pView, zLabel);
+ if( pWith ) n++;
+ if( pTabList ) n++;
+ if( pChanges ) n++;
+ if( pWhere ) n++;
+ if( pOrderBy ) n++;
+ if( pLimit ) n++;
+ if( pUpsert ) n++;
+ if( pTrigger ) n++;
+ if( pWith ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewWith(pView, pWith, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pTabList ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "FROM");
+ sqlite3TreeViewSrcList(pView, pTabList);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pChanges ){
+ sqlite3TreeViewExprList(pView, pChanges, (--n)>0, "SET");
+ }
+ if( pWhere ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "WHERE");
+ sqlite3TreeViewExpr(pView, pWhere, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pOrderBy ){
+ sqlite3TreeViewExprList(pView, pOrderBy, (--n)>0, "ORDER-BY");
+ }
+ if( pLimit ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "LIMIT");
+ sqlite3TreeViewExpr(pView, pLimit, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pUpsert ){
+ sqlite3TreeViewPush(&pView, (--n)>0);
+ sqlite3TreeViewLine(pView, "UPSERT");
+ sqlite3TreeViewUpsert(pView, pUpsert, 0);
+ sqlite3TreeViewPop(&pView);
+ }
+ if( pTrigger ){
+ sqlite3TreeViewTrigger(pView, pTrigger, (--n)>0, 1);
+ }
+ sqlite3TreeViewPop(&pView);
+}
+
+#ifndef SQLITE_OMIT_TRIGGER
+/*
+** Show a human-readable graph of a TriggerStep
+*/
+void sqlite3TreeViewTriggerStep(
+ TreeView *pView,
+ const TriggerStep *pStep,
+ u8 moreToFollow,
+ u8 showFullList
+){
+ int cnt = 0;
+ if( pStep==0 ) return;
+ sqlite3TreeViewPush(&pView,
+ moreToFollow || (showFullList && pStep->pNext!=0));
+ do{
+ if( cnt++ && pStep->pNext==0 ){
+ sqlite3TreeViewPop(&pView);
+ sqlite3TreeViewPush(&pView, 0);
+ }
+ sqlite3TreeViewLine(pView, "%s", pStep->zSpan ? pStep->zSpan : "RETURNING");
+ }while( showFullList && (pStep = pStep->pNext)!=0 );
+ sqlite3TreeViewPop(&pView);
+}
+
+/*
+** Show a human-readable graph of a Trigger
+*/
+void sqlite3TreeViewTrigger(
+ TreeView *pView,
+ const Trigger *pTrigger,
+ u8 moreToFollow,
+ u8 showFullList
+){
+ int cnt = 0;
+ if( pTrigger==0 ) return;
+ sqlite3TreeViewPush(&pView,
+ moreToFollow || (showFullList && pTrigger->pNext!=0));
+ do{
+ if( cnt++ && pTrigger->pNext==0 ){
+ sqlite3TreeViewPop(&pView);
+ sqlite3TreeViewPush(&pView, 0);
+ }
+ sqlite3TreeViewLine(pView, "TRIGGER %s", pTrigger->zName);
+ sqlite3TreeViewPush(&pView, 0);
+ sqlite3TreeViewTriggerStep(pView, pTrigger->step_list, 0, 1);
+ sqlite3TreeViewPop(&pView);
+ }while( showFullList && (pTrigger = pTrigger->pNext)!=0 );
+ sqlite3TreeViewPop(&pView);
+}
+#endif /* SQLITE_OMIT_TRIGGER */
+
+
+/*
+** These simplified versions of the tree-view routines omit unnecessary
+** parameters. These variants are intended to be used from a symbolic
+** debugger, such as "gdb", during interactive debugging sessions.
+**
+** This routines are given external linkage so that they will always be
+** accessible to the debugging, and to avoid warnings about unused
+** functions. But these routines only exist in debugging builds, so they
+** do not contaminate the interface.
+*/
+void sqlite3ShowExpr(const Expr *p){ sqlite3TreeViewExpr(0,p,0); }
+void sqlite3ShowExprList(const ExprList *p){ sqlite3TreeViewExprList(0,p,0,0);}
+void sqlite3ShowIdList(const IdList *p){ sqlite3TreeViewIdList(0,p,0,0); }
+void sqlite3ShowSrcList(const SrcList *p){ sqlite3TreeViewSrcList(0,p); }
+void sqlite3ShowSelect(const Select *p){ sqlite3TreeViewSelect(0,p,0); }
+void sqlite3ShowWith(const With *p){ sqlite3TreeViewWith(0,p,0); }
+void sqlite3ShowUpsert(const Upsert *p){ sqlite3TreeViewUpsert(0,p,0); }
+#ifndef SQLITE_OMIT_TRIGGER
+void sqlite3ShowTriggerStep(const TriggerStep *p){
+ sqlite3TreeViewTriggerStep(0,p,0,0);
+}
+void sqlite3ShowTriggerStepList(const TriggerStep *p){
+ sqlite3TreeViewTriggerStep(0,p,0,1);
+}
+void sqlite3ShowTrigger(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,0); }
+void sqlite3ShowTriggerList(const Trigger *p){ sqlite3TreeViewTrigger(0,p,0,1);}
+#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC
+void sqlite3ShowWindow(const Window *p){ sqlite3TreeViewWindow(0,p,0); }
+void sqlite3ShowWinFunc(const Window *p){ sqlite3TreeViewWinFunc(0,p,0); }
+#endif
+
#endif /* SQLITE_DEBUG */
diff --git a/src/trigger.c b/src/trigger.c
index 5df6b0c0bc..42c76bcd93 100644
--- a/src/trigger.c
+++ b/src/trigger.c
@@ -52,9 +52,7 @@ Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
Trigger *pList; /* List of triggers to return */
HashElem *p; /* Loop variable for TEMP triggers */
- if( pParse->disableTriggers ){
- return 0;
- }
+ assert( pParse->disableTriggers==0 );
pTmpSchema = pParse->db->aDb[1].pSchema;
p = sqliteHashFirst(&pTmpSchema->trigHash);
pList = pTab->pTrigger;
@@ -67,11 +65,10 @@ Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
){
pTrig->pNext = pList;
pList = pTrig;
- }else if( pTrig->op==TK_RETURNING
+ }else if( pTrig->op==TK_RETURNING ){
#ifndef SQLITE_OMIT_VIRTUALTABLE
- && pParse->db->pVtabCtx==0
+ assert( pParse->db->pVtabCtx==0 );
#endif
- ){
assert( pParse->bReturning );
assert( &(pParse->u1.pReturning->retTrig) == pTrig );
pTrig->table = pTab->zName;
@@ -730,13 +727,22 @@ static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){
return 0;
}
+/*
+** Return true if any TEMP triggers exist
+*/
+static int tempTriggersExist(sqlite3 *db){
+ if( NEVER(db->aDb[1].pSchema==0) ) return 0;
+ if( sqliteHashFirst(&db->aDb[1].pSchema->trigHash)==0 ) return 0;
+ return 1;
+}
+
/*
** Return a list of all triggers on table pTab if there exists at least
** one trigger that must be fired when an operation of type 'op' is
** performed on the table, and, if that operation is an UPDATE, if at
** least one of the columns in pChanges is being modified.
*/
-Trigger *sqlite3TriggersExist(
+static SQLITE_NOINLINE Trigger *triggersReallyExist(
Parse *pParse, /* Parse context */
Table *pTab, /* The table the contains the triggers */
int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
@@ -799,6 +805,22 @@ exit_triggers_exist:
}
return (mask ? pList : 0);
}
+Trigger *sqlite3TriggersExist(
+ Parse *pParse, /* Parse context */
+ Table *pTab, /* The table the contains the triggers */
+ int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
+ ExprList *pChanges, /* Columns that change in an UPDATE statement */
+ int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
+){
+ assert( pTab!=0 );
+ if( (pTab->pTrigger==0 && !tempTriggersExist(pParse->db))
+ || pParse->disableTriggers
+ ){
+ if( pMask ) *pMask = 0;
+ return 0;
+ }
+ return triggersReallyExist(pParse,pTab,op,pChanges,pMask);
+}
/*
** Convert the pStep->zTarget string into a SrcList and return a pointer
@@ -883,7 +905,7 @@ static ExprList *sqlite3ExpandReturning(
if( !db->mallocFailed ){
struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
pItem->zEName = sqlite3DbStrDup(db, pTab->aCol[jj].zCnName);
- pItem->eEName = ENAME_NAME;
+ pItem->fg.eEName = ENAME_NAME;
}
}
}else{
@@ -892,7 +914,7 @@ static ExprList *sqlite3ExpandReturning(
if( !db->mallocFailed && ALWAYS(pList->a[i].zEName!=0) ){
struct ExprList_item *pItem = &pNew->a[pNew->nExpr-1];
pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
- pItem->eEName = pList->a[i].eEName;
+ pItem->fg.eEName = pList->a[i].fg.eEName;
}
}
}
diff --git a/src/update.c b/src/update.c
index a43d0eac53..6547041472 100644
--- a/src/update.c
+++ b/src/update.c
@@ -376,6 +376,14 @@ void sqlite3Update(
# define isView 0
#endif
+#if TREETRACE_ENABLED
+ if( sqlite3TreeTrace & 0x10000 ){
+ sqlite3TreeViewLine(0, "In sqlite3Update() at %s:%d", __FILE__, __LINE__);
+ sqlite3TreeViewUpdate(pParse->pWith, pTabList, pChanges, pWhere,
+ onError, pOrderBy, pLimit, pUpsert, pTrigger);
+ }
+#endif
+
/* If there was a FROM clause, set nChangeFrom to the number of expressions
** in the change-list. Otherwise, set it to 0. There cannot be a FROM
** clause if this function is being called to generate code for part of
diff --git a/src/vacuum.c b/src/vacuum.c
index bcab1de142..9899b63cf1 100644
--- a/src/vacuum.c
+++ b/src/vacuum.c
@@ -368,6 +368,7 @@ SQLITE_NOINLINE int sqlite3RunVacuum(
assert( rc==SQLITE_OK );
if( pOut==0 ){
+ nRes = sqlite3BtreeGetRequestedReserve(pTemp);
rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1);
}
diff --git a/src/vdbe.c b/src/vdbe.c
index 079be3ad05..518d935956 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -266,12 +266,12 @@ static VdbeCursor *allocateCursor(
int nByte;
VdbeCursor *pCx = 0;
nByte =
- ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
+ ROUND8P(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
(eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
assert( iCur>=0 && iCurnCursor );
if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
- sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
+ sqlite3VdbeFreeCursorNN(p, p->apCsr[iCur]);
p->apCsr[iCur] = 0;
}
@@ -301,7 +301,7 @@ static VdbeCursor *allocateCursor(
pCx->aOffset = &pCx->aType[nField];
if( eCurType==CURTYPE_BTREE ){
pCx->uc.pCursor = (BtCursor*)
- &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
+ &pMem->z[ROUND8P(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
sqlite3BtreeCursorZero(pCx->uc.pCursor);
}
return pCx;
@@ -740,7 +740,7 @@ int sqlite3VdbeExec(
#endif
/*** INSERT STACK UNION HERE ***/
- assert( p->iVdbeMagic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
+ assert( p->eVdbeState==VDBE_RUN_STATE ); /* sqlite3_step() verifies this */
sqlite3VdbeEnter(p);
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
if( db->xProgress ){
@@ -983,28 +983,39 @@ case OP_Gosub: { /* jump */
pIn1->flags = MEM_Int;
pIn1->u.i = (int)(pOp-aOp);
REGISTER_TRACE(pOp->p1, pIn1);
-
- /* Most jump operations do a goto to this spot in order to update
- ** the pOp pointer. */
-jump_to_p2:
- pOp = &aOp[pOp->p2 - 1];
- break;
+ goto jump_to_p2_and_check_for_interrupt;
}
-/* Opcode: Return P1 * P3 * *
+/* Opcode: Return P1 P2 P3 * *
**
-** Jump to the next instruction after the address in register P1. After
-** the jump, register P1 becomes undefined.
+** Jump to the address stored in register P1. If P1 is a return address
+** register, then this accomplishes a return from a subroutine.
**
-** P3 is not used by the byte-code engine. However, the code generator
-** sets P3 to address of the associated OP_BeginSubrtn opcode, if there is
-** one.
+** If P3 is 1, then the jump is only taken if register P1 holds an integer
+** values, otherwise execution falls through to the next opcode, and the
+** OP_Return becomes a no-op. If P3 is 0, then register P1 must hold an
+** integer or else an assert() is raised. P3 should be set to 1 when
+** this opcode is used in combination with OP_BeginSubrtn, and set to 0
+** otherwise.
+**
+** The value in register P1 is unchanged by this opcode.
+**
+** P2 is not used by the byte-code engine. However, if P2 is positive
+** and also less than the current address, then the "EXPLAIN" output
+** formatter in the CLI will indent all opcodes from the P2 opcode up
+** to be not including the current Return. P2 should be the first opcode
+** in the subroutine from which this opcode is returnning. Thus the P2
+** value is a byte-code indentation hint. See tag-20220407a in
+** wherecode.c and shell.c.
*/
case OP_Return: { /* in1 */
pIn1 = &aMem[pOp->p1];
- assert( pIn1->flags==MEM_Int );
- pOp = &aOp[pIn1->u.i];
- pIn1->flags = MEM_Undefined;
+ if( pIn1->flags & MEM_Int ){
+ if( pOp->p3 ){ VdbeBranchTaken(1, 2); }
+ pOp = &aOp[pIn1->u.i];
+ }else if( ALWAYS(pOp->p3) ){
+ VdbeBranchTaken(0, 2);
+ }
break;
}
@@ -1027,7 +1038,14 @@ case OP_InitCoroutine: { /* jump */
assert( !VdbeMemDynamic(pOut) );
pOut->u.i = pOp->p3 - 1;
pOut->flags = MEM_Int;
- if( pOp->p2 ) goto jump_to_p2;
+ if( pOp->p2==0 ) break;
+
+ /* Most jump operations do a goto to this spot in order to update
+ ** the pOp pointer. */
+jump_to_p2:
+ assert( pOp->p2>0 ); /* There are never any jumps to instruction 0 */
+ assert( pOp->p2nOp ); /* Jumps must be in range */
+ pOp = &aOp[pOp->p2 - 1];
break;
}
@@ -1129,11 +1147,10 @@ case OP_Halt: {
VdbeFrame *pFrame;
int pcx;
- pcx = (int)(pOp - aOp);
#ifdef SQLITE_DEBUG
if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
#endif
- if( pOp->p1==SQLITE_OK && p->pFrame ){
+ if( p->pFrame && pOp->p1==SQLITE_OK ){
/* Halt the sub-program. Return control to the parent frame. */
pFrame = p->pFrame;
p->pFrame = pFrame->pParent;
@@ -1155,7 +1172,6 @@ case OP_Halt: {
}
p->rc = pOp->p1;
p->errorAction = (u8)pOp->p2;
- p->pc = pcx;
assert( pOp->p5<=4 );
if( p->rc ){
if( pOp->p5 ){
@@ -1172,6 +1188,7 @@ case OP_Halt: {
}else{
sqlite3VdbeError(p, "%s", pOp->p4.z);
}
+ pcx = (int)(pOp - aOp);
sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg);
}
rc = sqlite3VdbeHalt(p);
@@ -1186,22 +1203,11 @@ case OP_Halt: {
goto vdbe_return;
}
-/* Opcode: BeginSubrtn P1 P2 * * *
-** Synopsis: r[P2]=P1
-**
-** Mark the beginning of a subroutine by loading the integer value P1
-** into register r[P2]. The P2 register is used to store the return
-** address of the subroutine call.
-**
-** This opcode is identical to OP_Integer. It has a different name
-** only to make the byte code easier to read and verify.
-*/
/* Opcode: Integer P1 P2 * * *
** Synopsis: r[P2]=P1
**
** The 32-bit integer value P1 is written into register P2.
*/
-case OP_BeginSubrtn:
case OP_Integer: { /* out2 */
pOut = out2Prerelease(p, pOp);
pOut->u.i = pOp->p1;
@@ -1308,6 +1314,28 @@ case OP_String: { /* out2 */
break;
}
+/* Opcode: BeginSubrtn * P2 * * *
+** Synopsis: r[P2]=NULL
+**
+** Mark the beginning of a subroutine that can be entered in-line
+** or that can be called using OP_Gosub. The subroutine should
+** be terminated by an OP_Return instruction that has a P1 operand that
+** is the same as the P2 operand to this opcode and that has P3 set to 1.
+** If the subroutine is entered in-line, then the OP_Return will simply
+** fall through. But if the subroutine is entered using OP_Gosub, then
+** the OP_Return will jump back to the first instruction after the OP_Gosub.
+**
+** This routine works by loading a NULL into the P2 register. When the
+** return address register contains a NULL, the OP_Return instruction is
+** a no-op that simply falls through to the next instruction (assuming that
+** the OP_Return opcode has a P3 value of 1). Thus if the subroutine is
+** entered in-line, then the OP_Return will cause in-line execution to
+** continue. But if the subroutine is entered via OP_Gosub, then the
+** OP_Return will cause a return to the address following the OP_Gosub.
+**
+** This opcode is identical to OP_Null. It has a different name
+** only to make the byte code easier to read and verify.
+*/
/* Opcode: Null P1 P2 P3 * *
** Synopsis: r[P2..P3]=NULL
**
@@ -1320,6 +1348,7 @@ case OP_String: { /* out2 */
** NULL values will not compare equal even if SQLITE_NULLEQ is set on
** OP_Ne or OP_Eq.
*/
+case OP_BeginSubrtn:
case OP_Null: { /* out2 */
int cnt;
u16 nullFlag;
@@ -1549,45 +1578,32 @@ case OP_FkCheck: {
** the result row.
*/
case OP_ResultRow: {
- Mem *pMem;
- int i;
assert( p->nResColumn==pOp->p2 );
assert( pOp->p1>0 || CORRUPT_DB );
assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
- /* Invalidate all ephemeral cursor row caches */
p->cacheCtr = (p->cacheCtr + 2)|1;
-
- /* Make sure the results of the current row are \000 terminated
- ** and have an assigned type. The results are de-ephemeralized as
- ** a side effect.
- */
- pMem = p->pResultSet = &aMem[pOp->p1];
- for(i=0; ip2; i++){
- assert( memIsValid(&pMem[i]) );
- Deephemeralize(&pMem[i]);
- assert( (pMem[i].flags & MEM_Ephem)==0
- || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
- sqlite3VdbeMemNulTerminate(&pMem[i]);
- REGISTER_TRACE(pOp->p1+i, &pMem[i]);
+ p->pResultSet = &aMem[pOp->p1];
#ifdef SQLITE_DEBUG
- /* The registers in the result will not be used again when the
- ** prepared statement restarts. This is because sqlite3_column()
- ** APIs might have caused type conversions of made other changes to
- ** the register values. Therefore, we can go ahead and break any
- ** OP_SCopy dependencies. */
- pMem[i].pScopyFrom = 0;
-#endif
+ {
+ Mem *pMem = p->pResultSet;
+ int i;
+ for(i=0; ip2; i++){
+ assert( memIsValid(&pMem[i]) );
+ REGISTER_TRACE(pOp->p1+i, &pMem[i]);
+ /* The registers in the result will not be used again when the
+ ** prepared statement restarts. This is because sqlite3_column()
+ ** APIs might have caused type conversions of made other changes to
+ ** the register values. Therefore, we can go ahead and break any
+ ** OP_SCopy dependencies. */
+ pMem[i].pScopyFrom = 0;
+ }
}
+#endif
if( db->mallocFailed ) goto no_mem;
-
if( db->mTrace & SQLITE_TRACE_ROW ){
db->trace.xV2(SQLITE_TRACE_ROW, db->pTraceArg, p, 0);
}
-
-
- /* Return SQLITE_ROW
- */
p->pc = (int)(pOp - aOp) + 1;
rc = SQLITE_ROW;
goto vdbe_return;
@@ -2101,23 +2117,23 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */
assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT || CORRUPT_DB );
/* Common case of comparison of two integers */
if( pIn3->u.i > pIn1->u.i ){
- iCompare = +1;
if( sqlite3aGTb[pOp->opcode] ){
VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
goto jump_to_p2;
}
+ iCompare = +1;
}else if( pIn3->u.i < pIn1->u.i ){
- iCompare = -1;
if( sqlite3aLTb[pOp->opcode] ){
VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
goto jump_to_p2;
}
+ iCompare = -1;
}else{
- iCompare = 0;
if( sqlite3aEQb[pOp->opcode] ){
VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
goto jump_to_p2;
}
+ iCompare = 0;
}
VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
break;
@@ -2144,11 +2160,11 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */
** then the result is always NULL.
** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
*/
- iCompare = 1; /* Operands are not equal */
VdbeBranchTaken(2,3);
if( pOp->p5 & SQLITE_JUMPIFNULL ){
goto jump_to_p2;
}
+ iCompare = 1; /* Operands are not equal */
break;
}
}else{
@@ -2254,9 +2270,8 @@ case OP_ElseEq: { /* same as TK_ESCAPE, jump */
** Set the permutation used by the OP_Compare operator in the next
** instruction. The permutation is stored in the P4 operand.
**
-** The permutation is only valid until the next OP_Compare that has
-** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should
-** occur immediately prior to the OP_Compare.
+** The permutation is only valid for the next opcode which must be
+** an OP_Compare that has the OPFLAG_PERMUTE bit set in P5.
**
** The first integer in the P4 integer array is the length of the array
** and does not become part of the permutation.
@@ -2288,6 +2303,8 @@ case OP_Permutation: {
** The comparison is a sort comparison, so NULLs compare equal,
** NULLs are less than numbers, numbers are less than strings,
** and strings are less than blobs.
+**
+** This opcode must be immediately followed by an OP_Jump opcode.
*/
case OP_Compare: {
int n;
@@ -2346,6 +2363,7 @@ case OP_Compare: {
break;
}
}
+ assert( pOp[1].opcode==OP_Jump );
break;
}
@@ -2354,8 +2372,11 @@ case OP_Compare: {
** Jump to the instruction at address P1, P2, or P3 depending on whether
** in the most recent OP_Compare instruction the P1 vector was less than
** equal to, or greater than the P2 vector, respectively.
+**
+** This opcode must immediately follow an OP_Compare opcode.
*/
case OP_Jump: { /* jump */
+ assert( pOp>aOp && pOp[-1].opcode==OP_Compare );
if( iCompare<0 ){
VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
}else if( iCompare==0 ){
@@ -2660,7 +2681,7 @@ case OP_Offset: { /* out3 */
#endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */
/* Opcode: Column P1 P2 P3 P4 P5
-** Synopsis: r[P3]=PX
+** Synopsis: r[P3]=PX cursor P1 column P2
**
** Interpret the data that cursor P1 points to as a structure built using
** the MakeRecord instruction. (See the MakeRecord opcode for additional
@@ -2702,7 +2723,8 @@ case OP_Column: {
op_column_restart:
assert( pC!=0 );
- assert( p2<(u32)pC->nField );
+ assert( p2<(u32)pC->nField
+ || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) );
aOffset = pC->aOffset;
assert( aOffset==pC->aType+pC->nField );
assert( pC->eCurType!=CURTYPE_VTAB );
@@ -2711,10 +2733,9 @@ op_column_restart:
if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
if( pC->nullRow ){
- if( pC->eCurType==CURTYPE_PSEUDO ){
+ if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){
/* For the special case of as pseudo-cursor, the seekResult field
** identifies the register that holds the record */
- assert( pC->seekResult>0 );
pReg = &aMem[pC->seekResult];
assert( pReg->flags & MEM_Blob );
assert( memIsValid(pReg) );
@@ -2752,7 +2773,11 @@ op_column_restart:
assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
}
pC->cacheStatus = p->cacheCtr;
- pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
+ if( (aOffset[0] = pC->aRow[0])<0x80 ){
+ pC->iHdrOffset = 1;
+ }else{
+ pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset);
+ }
pC->nHdrParsed = 0;
if( pC->szRowuTemp;
/* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
- ** additional varints, one per column. */
- zHdr += putVarint32(zHdr, serial_type); /* serial type */
- /* EVIDENCE-OF: R-64536-51728 The values for each column in the record
+ ** additional varints, one per column.
+ ** EVIDENCE-OF: R-64536-51728 The values for each column in the record
** immediately follow the header. */
- zPayload += sqlite3VdbeSerialPut(zPayload, pRec, serial_type); /* content */
- }while( (++pRec)<=pLast );
+ if( serial_type<=7 ){
+ *(zHdr++) = serial_type;
+ if( serial_type==0 ){
+ /* NULL value. No change in zPayload */
+ }else{
+ u64 v;
+ u32 i;
+ if( serial_type==7 ){
+ assert( sizeof(v)==sizeof(pRec->u.r) );
+ memcpy(&v, &pRec->u.r, sizeof(v));
+ swapMixedEndianFloat(v);
+ }else{
+ v = pRec->u.i;
+ }
+ len = i = sqlite3SmallTypeSizes[serial_type];
+ assert( i>0 );
+ while( 1 /*exit-by-break*/ ){
+ zPayload[--i] = (u8)(v&0xFF);
+ if( i==0 ) break;
+ v >>= 8;
+ }
+ zPayload += len;
+ }
+ }else if( serial_type<0x80 ){
+ *(zHdr++) = serial_type;
+ if( serial_type>=14 && pRec->n>0 ){
+ assert( pRec->z!=0 );
+ memcpy(zPayload, pRec->z, pRec->n);
+ zPayload += pRec->n;
+ }
+ }else{
+ zHdr += sqlite3PutVarint(zHdr, serial_type);
+ if( pRec->n ){
+ assert( pRec->z!=0 );
+ memcpy(zPayload, pRec->z, pRec->n);
+ zPayload += pRec->n;
+ }
+ }
+ if( pRec==pLast ) break;
+ pRec++;
+ }
assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
assert( nByte==(int)(zPayload - (u8*)pOut->z) );
@@ -3617,7 +3684,10 @@ case OP_Savepoint: {
}
}
if( rc ) goto abort_due_to_error;
-
+ if( p->eVdbeState==VDBE_HALT_STATE ){
+ rc = SQLITE_DONE;
+ goto vdbe_return;
+ }
break;
}
@@ -3721,6 +3791,7 @@ case OP_AutoCommit: {
*/
case OP_Transaction: {
Btree *pBt;
+ Db *pDb;
int iMeta = 0;
assert( p->bIsReader );
@@ -3740,7 +3811,8 @@ case OP_Transaction: {
}
goto abort_due_to_error;
}
- pBt = db->aDb[pOp->p1].pBt;
+ pDb = &db->aDb[pOp->p1];
+ pBt = pDb->pBt;
if( pBt ){
rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
@@ -3781,8 +3853,7 @@ case OP_Transaction: {
assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
if( rc==SQLITE_OK
&& pOp->p5
- && (iMeta!=pOp->p3
- || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i)
+ && (iMeta!=pOp->p3 || pDb->pSchema->iGeneration!=pOp->p4.i)
){
/*
** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
@@ -4925,11 +4996,8 @@ case OP_NoConflict: /* jump, in3 */
case OP_NotFound: /* jump, in3 */
case OP_Found: { /* jump, in3 */
int alreadyExists;
- int takeJump;
int ii;
VdbeCursor *pC;
- int res;
- UnpackedRecord *pFree;
UnpackedRecord *pIdxKey;
UnpackedRecord r;
@@ -4944,14 +5012,15 @@ case OP_Found: { /* jump, in3 */
#ifdef SQLITE_DEBUG
pC->seekOp = pOp->opcode;
#endif
- pIn3 = &aMem[pOp->p3];
+ r.aMem = &aMem[pOp->p3];
assert( pC->eCurType==CURTYPE_BTREE );
assert( pC->uc.pCursor!=0 );
assert( pC->isTable==0 );
- if( pOp->p4.i>0 ){
+ r.nField = (u16)pOp->p4.i;
+ if( r.nField>0 ){
+ /* Key values in an array of registers */
r.pKeyInfo = pC->pKeyInfo;
- r.nField = (u16)pOp->p4.i;
- r.aMem = pIn3;
+ r.default_rc = 0;
#ifdef SQLITE_DEBUG
for(ii=0; iip3+ii, &r.aMem[ii]);
}
#endif
- pIdxKey = &r;
- pFree = 0;
+ rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult);
}else{
- assert( pIn3->flags & MEM_Blob );
- rc = ExpandBlob(pIn3);
+ /* Composite key generated by OP_MakeRecord */
+ assert( r.aMem->flags & MEM_Blob );
+ assert( pOp->opcode!=OP_NoConflict );
+ rc = ExpandBlob(r.aMem);
assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
if( rc ) goto no_mem;
- pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
+ pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
if( pIdxKey==0 ) goto no_mem;
- sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
+ sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey);
+ pIdxKey->default_rc = 0;
+ rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult);
+ sqlite3DbFreeNN(db, pIdxKey);
}
- pIdxKey->default_rc = 0;
- takeJump = 0;
- if( pOp->opcode==OP_NoConflict ){
- /* For the OP_NoConflict opcode, take the jump if any of the
- ** input fields are NULL, since any key with a NULL will not
- ** conflict */
- for(ii=0; iinField; ii++){
- if( pIdxKey->aMem[ii].flags & MEM_Null ){
- takeJump = 1;
- break;
- }
- }
- }
- rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &res);
- if( pFree ) sqlite3DbFreeNN(db, pFree);
if( rc!=SQLITE_OK ){
goto abort_due_to_error;
}
- pC->seekResult = res;
- alreadyExists = (res==0);
+ alreadyExists = (pC->seekResult==0);
pC->nullRow = 1-alreadyExists;
pC->deferredMoveto = 0;
pC->cacheStatus = CACHE_STALE;
@@ -4997,9 +5054,25 @@ case OP_Found: { /* jump, in3 */
VdbeBranchTaken(alreadyExists!=0,2);
if( alreadyExists ) goto jump_to_p2;
}else{
- VdbeBranchTaken(takeJump||alreadyExists==0,2);
- if( takeJump || !alreadyExists ) goto jump_to_p2;
- if( pOp->opcode==OP_IfNoHope ) pC->seekHit = pOp->p4.i;
+ if( !alreadyExists ){
+ VdbeBranchTaken(1,2);
+ goto jump_to_p2;
+ }
+ if( pOp->opcode==OP_NoConflict ){
+ /* For the OP_NoConflict opcode, take the jump if any of the
+ ** input fields are NULL, since any key with a NULL will not
+ ** conflict */
+ for(ii=0; iiopcode==OP_IfNoHope ){
+ pC->seekHit = pOp->p4.i;
+ }
}
break;
}
@@ -5690,7 +5763,7 @@ case OP_RowData: {
}
/* Opcode: Rowid P1 P2 * * *
-** Synopsis: r[P2]=rowid
+** Synopsis: r[P2]=PX rowid of P1
**
** Store in register P2 an integer which is the key of the table entry that
** P1 is currently point to.
@@ -5746,16 +5819,23 @@ case OP_Rowid: { /* out2 */
** that occur while the cursor is on the null row will always
** write a NULL.
**
-** Or, if P1 is a Pseudo-Cursor (a cursor opened using OP_OpenPseudo)
-** just reset the cache for that cursor. This causes the row of
-** content held by the pseudo-cursor to be reparsed.
+** If cursor P1 is not previously opened, open it now to a special
+** pseudo-cursor that always returns NULL for every column.
*/
case OP_NullRow: {
VdbeCursor *pC;
assert( pOp->p1>=0 && pOp->p1nCursor );
pC = p->apCsr[pOp->p1];
- assert( pC!=0 );
+ if( pC==0 ){
+ /* If the cursor is not already open, create a special kind of
+ ** pseudo-cursor that always gives null rows. */
+ pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO);
+ if( pC==0 ) goto no_mem;
+ pC->seekResult = 0;
+ pC->isTable = 1;
+ pC->uc.pCursor = sqlite3BtreeFakeValidCursor();
+ }
pC->nullRow = 1;
pC->cacheStatus = CACHE_STALE;
if( pC->eCurType==CURTYPE_BTREE ){
@@ -6202,9 +6282,9 @@ case OP_IdxRowid: { /* out2 */
assert( pOp->p1>=0 && pOp->p1nCursor );
pC = p->apCsr[pOp->p1];
assert( pC!=0 );
- assert( pC->eCurType==CURTYPE_BTREE );
+ assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) );
assert( pC->uc.pCursor!=0 );
- assert( pC->isTable==0 );
+ assert( pC->isTable==0 || IsNullCursor(pC) );
assert( pC->deferredMoveto==0 );
assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
@@ -7249,6 +7329,7 @@ case OP_AggStep: {
pCtx->pVdbe = p;
pCtx->skipFlag = 0;
pCtx->isError = 0;
+ pCtx->enc = encoding;
pCtx->argc = n;
pOp->p4type = P4_FUNCCTX;
pOp->p4.pCtx = pCtx;
@@ -7378,9 +7459,6 @@ case OP_AggFinal: {
}
sqlite3VdbeChangeEncoding(pMem, encoding);
UPDATE_MAX_BLOBSIZE(pMem);
- if( sqlite3VdbeMemTooBig(pMem) ){
- goto too_big;
- }
break;
}
@@ -7913,6 +7991,7 @@ case OP_VColumn: {
assert( pModule->xColumn );
memset(&sContext, 0, sizeof(sContext));
sContext.pOut = pDest;
+ sContext.enc = encoding;
assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
if( pOp->p5 & OPFLAG_NOCHNG ){
sqlite3VdbeMemSetNull(pDest);
@@ -7931,9 +8010,6 @@ case OP_VColumn: {
REGISTER_TRACE(pOp->p3, pDest);
UPDATE_MAX_BLOBSIZE(pDest);
- if( sqlite3VdbeMemTooBig(pDest) ){
- goto too_big;
- }
if( rc ) goto abort_due_to_error;
break;
}
@@ -8200,6 +8276,7 @@ case OP_Function: { /* group */
if( pCtx->pOut != pOut ){
pCtx->pVdbe = p;
pCtx->pOut = pOut;
+ pCtx->enc = encoding;
for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
}
assert( pCtx->pVdbe==p );
@@ -8226,11 +8303,10 @@ case OP_Function: { /* group */
if( rc ) goto abort_due_to_error;
}
- /* Copy the result of the function into register P3 */
- if( pOut->flags & (MEM_Str|MEM_Blob) ){
- sqlite3VdbeChangeEncoding(pOut, encoding);
- if( sqlite3VdbeMemTooBig(pOut) ) goto too_big;
- }
+ assert( (pOut->flags&MEM_Str)==0
+ || pOut->enc==encoding
+ || db->mallocFailed );
+ assert( !sqlite3VdbeMemTooBig(pOut) );
REGISTER_TRACE(pOp->p3, pOut);
UPDATE_MAX_BLOBSIZE(pOut);
@@ -8356,7 +8432,7 @@ case OP_Init: { /* jump */
#ifndef SQLITE_OMIT_TRACE
if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0
- && !p->doingRerun
+ && p->minWriteFileFormat!=254 /* tag-20220401a */
&& (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
){
#ifndef SQLITE_OMIT_DEPRECATED
@@ -8585,7 +8661,7 @@ abort_due_to_error:
testcase( sqlite3GlobalConfig.xLog!=0 );
sqlite3_log(rc, "statement aborts at %d: [%s] %s",
(int)(pOp - aOp), p->zSql, p->zErrMsg);
- sqlite3VdbeHalt(p);
+ if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p);
if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
if( rc==SQLITE_CORRUPT && db->autoCommit==0 ){
db->flags |= SQLITE_CorruptRdOnly;
diff --git a/src/vdbe.h b/src/vdbe.h
index fb383e3ed2..5909d3995d 100644
--- a/src/vdbe.h
+++ b/src/vdbe.h
@@ -198,8 +198,10 @@ void sqlite3VdbeEndCoroutine(Vdbe*,int);
#endif
#if defined(SQLITE_DEBUG)
void sqlite3VdbeVerifyAbortable(Vdbe *p, int);
+ void sqlite3VdbeNoJumpsOutsideSubrtn(Vdbe*,int,int,int);
#else
# define sqlite3VdbeVerifyAbortable(A,B)
+# define sqlite3VdbeNoJumpsOutsideSubrtn(A,B,C,D)
#endif
VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno);
#ifndef SQLITE_OMIT_EXPLAIN
@@ -244,7 +246,6 @@ int sqlite3VdbeMakeLabel(Parse*);
void sqlite3VdbeRunOnlyOnce(Vdbe*);
void sqlite3VdbeReusable(Vdbe*);
void sqlite3VdbeDelete(Vdbe*);
-void sqlite3VdbeClearObject(sqlite3*,Vdbe*);
void sqlite3VdbeMakeReady(Vdbe*,Parse*);
int sqlite3VdbeFinalize(Vdbe*);
void sqlite3VdbeResolveLabel(Vdbe*, int);
diff --git a/src/vdbeInt.h b/src/vdbeInt.h
index 45720b6a55..2a2e403173 100644
--- a/src/vdbeInt.h
+++ b/src/vdbeInt.h
@@ -134,6 +134,11 @@ struct VdbeCursor {
u32 aType[1]; /* Type values record decode. MUST BE LAST */
};
+/* Return true if P is a null-only cursor
+*/
+#define IsNullCursor(P) \
+ ((P)->eCurType==CURTYPE_PSEUDO && (P)->nullRow && (P)->seekResult==0)
+
/*
** A value for VdbeCursor.cacheStatus that means the cache is always invalid.
@@ -369,6 +374,7 @@ struct sqlite3_context {
Vdbe *pVdbe; /* The VM that owns this context */
int iOp; /* Instruction number of OP_Function */
int isError; /* Error code returned by the function. */
+ u8 enc; /* Encoding to use for results */
u8 skipFlag; /* Skip accumulator loading if true */
u8 argc; /* Number of arguments */
sqlite3_value *argv[1]; /* Argument set */
@@ -417,7 +423,6 @@ struct Vdbe {
Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
Parse *pParse; /* Parsing context used to create this Vdbe */
ynVar nVar; /* Number of entries in aVar[] */
- u32 iVdbeMagic; /* Magic number defining state of the SQL statement */
int nMem; /* Number of memory locations currently allocated */
int nCursor; /* Number of slots in apCsr[] */
u32 cacheCtr; /* VdbeCursor row cache generation counter */
@@ -455,11 +460,10 @@ struct Vdbe {
u8 errorAction; /* Recovery action to do in case of an error */
u8 minWriteFileFormat; /* Minimum file format for writable database files */
u8 prepFlags; /* SQLITE_PREPARE_* flags */
- u8 doingRerun; /* True if rerunning after an auto-reprepare */
+ u8 eVdbeState; /* On of the VDBE_*_STATE values */
bft expired:2; /* 1: recompile VM immediately 2: when convenient */
bft explain:2; /* True if EXPLAIN present on SQL command */
bft changeCntOn:1; /* True to update the change-counter */
- bft runOnlyOnce:1; /* Automatically expire on reset */
bft usesStmtJournal:1; /* True if uses a statement journal */
bft readOnly:1; /* True for statements that do not write */
bft bIsReader:1; /* True for statements that read */
@@ -486,13 +490,12 @@ struct Vdbe {
};
/*
-** The following are allowed values for Vdbe.magic
+** The following are allowed values for Vdbe.eVdbeState
*/
-#define VDBE_MAGIC_INIT 0x16bceaa5 /* Building a VDBE program */
-#define VDBE_MAGIC_RUN 0x2df20da3 /* VDBE is ready to execute */
-#define VDBE_MAGIC_HALT 0x319c2973 /* VDBE has completed execution */
-#define VDBE_MAGIC_RESET 0x48fa9f76 /* Reset and ready to run again */
-#define VDBE_MAGIC_DEAD 0x5606c3c8 /* The VDBE has been deallocated */
+#define VDBE_INIT_STATE 0 /* Prepared statement under construction */
+#define VDBE_READY_STATE 1 /* Ready to run but not yet started */
+#define VDBE_RUN_STATE 2 /* Run in progress */
+#define VDBE_HALT_STATE 3 /* Finished. Need reset() or finalize() */
/*
** Structure used to store the context required by the
@@ -533,18 +536,31 @@ struct ValueList {
sqlite3_value *pOut; /* Register to hold each decoded output value */
};
+/* Size of content associated with serial types that fit into a
+** single-byte varint.
+*/
+#ifndef SQLITE_AMALGAMATION
+extern const u8 sqlite3SmallTypeSizes[];
+#endif
+
/*
** Function prototypes
*/
void sqlite3VdbeError(Vdbe*, const char *, ...);
void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
+void sqlite3VdbeFreeCursorNN(Vdbe*,VdbeCursor*);
void sqliteVdbePopStack(Vdbe*,int);
int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p);
int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor*);
int sqlite3VdbeCursorRestore(VdbeCursor*);
u32 sqlite3VdbeSerialTypeLen(u32);
u8 sqlite3VdbeOneByteSerialTypeLen(u8);
-u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32);
+#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
+ u64 sqlite3FloatSwap(u64 in);
+# define swapMixedEndianFloat(X) X = sqlite3FloatSwap(X)
+#else
+# define swapMixedEndianFloat(X)
+#endif
void sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
void sqlite3VdbeDeleteAuxData(sqlite3*, AuxData**, int, int);
diff --git a/src/vdbeapi.c b/src/vdbeapi.c
index 83f7b0fd65..39d73288ce 100644
--- a/src/vdbeapi.c
+++ b/src/vdbeapi.c
@@ -345,6 +345,9 @@ sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
sqlite3ValueFree(pNew);
pNew = 0;
}
+ }else if( pNew->flags & MEM_Null ){
+ /* Do not duplicate pointer values */
+ pNew->flags &= ~(MEM_Term|MEM_Subtype);
}
return pNew;
}
@@ -375,7 +378,8 @@ static void setResultStrOrError(
u8 enc, /* Encoding of z. 0 for BLOBs */
void (*xDel)(void*) /* Destructor function */
){
- int rc = sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel);
+ Mem *pOut = pCtx->pOut;
+ int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
if( rc ){
if( rc==SQLITE_TOOBIG ){
sqlite3_result_error_toobig(pCtx);
@@ -385,6 +389,11 @@ static void setResultStrOrError(
assert( rc==SQLITE_NOMEM );
sqlite3_result_error_nomem(pCtx);
}
+ return;
+ }
+ sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
+ if( sqlite3VdbeMemTooBig(pOut) ){
+ sqlite3_result_error_toobig(pCtx);
}
}
static int invokeValueDestructor(
@@ -528,17 +537,22 @@ void sqlite3_result_text16le(
}
#endif /* SQLITE_OMIT_UTF16 */
void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
+ Mem *pOut = pCtx->pOut;
assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
- sqlite3VdbeMemCopy(pCtx->pOut, pValue);
+ sqlite3VdbeMemCopy(pOut, pValue);
+ sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
+ if( sqlite3VdbeMemTooBig(pOut) ){
+ sqlite3_result_error_toobig(pCtx);
+ }
}
void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
- assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
- sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
+ sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0);
}
int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
Mem *pOut = pCtx->pOut;
assert( sqlite3_mutex_held(pOut->db->mutex) );
if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
+ sqlite3_result_error_toobig(pCtx);
return SQLITE_TOOBIG;
}
#ifndef SQLITE_OMIT_INCRBLOB
@@ -554,8 +568,8 @@ void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
#endif
if( pCtx->pOut->flags & MEM_Null ){
- sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,
- SQLITE_UTF8, SQLITE_STATIC);
+ setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8,
+ SQLITE_STATIC);
}
}
@@ -629,80 +643,83 @@ static int sqlite3Step(Vdbe *p){
int rc;
assert(p);
- if( p->iVdbeMagic!=VDBE_MAGIC_RUN ){
- /* We used to require that sqlite3_reset() be called before retrying
- ** sqlite3_step() after any error or after SQLITE_DONE. But beginning
- ** with version 3.7.0, we changed this so that sqlite3_reset() would
- ** be called automatically instead of throwing the SQLITE_MISUSE error.
- ** This "automatic-reset" change is not technically an incompatibility,
- ** since any application that receives an SQLITE_MISUSE is broken by
- ** definition.
- **
- ** Nevertheless, some published applications that were originally written
- ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
- ** returns, and those were broken by the automatic-reset change. As a
- ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
- ** legacy behavior of returning SQLITE_MISUSE for cases where the
- ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
- ** or SQLITE_BUSY error.
- */
-#ifdef SQLITE_OMIT_AUTORESET
- if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
- sqlite3_reset((sqlite3_stmt*)p);
- }else{
- return SQLITE_MISUSE_BKPT;
- }
-#else
- sqlite3_reset((sqlite3_stmt*)p);
-#endif
- }
-
- /* Check that malloc() has not failed. If it has, return early. */
db = p->db;
- if( db->mallocFailed ){
- p->rc = SQLITE_NOMEM;
- return SQLITE_NOMEM_BKPT;
- }
+ if( p->eVdbeState!=VDBE_RUN_STATE ){
+ restart_step:
+ if( p->eVdbeState==VDBE_READY_STATE ){
+ if( p->expired ){
+ p->rc = SQLITE_SCHEMA;
+ rc = SQLITE_ERROR;
+ if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
+ /* If this statement was prepared using saved SQL and an
+ ** error has occurred, then return the error code in p->rc to the
+ ** caller. Set the error code in the database handle to the same
+ ** value.
+ */
+ rc = sqlite3VdbeTransferError(p);
+ }
+ goto end_of_step;
+ }
- if( p->pc<0 && p->expired ){
- p->rc = SQLITE_SCHEMA;
- rc = SQLITE_ERROR;
- if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
- /* If this statement was prepared using saved SQL and an
- ** error has occurred, then return the error code in p->rc to the
- ** caller. Set the error code in the database handle to the same value.
- */
- rc = sqlite3VdbeTransferError(p);
- }
- goto end_of_step;
- }
- if( p->pc<0 ){
- /* If there are no other statements currently running, then
- ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
- ** from interrupting a statement that has not yet started.
- */
- if( db->nVdbeActive==0 ){
- AtomicStore(&db->u1.isInterrupted, 0);
- }
+ /* If there are no other statements currently running, then
+ ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
+ ** from interrupting a statement that has not yet started.
+ */
+ if( db->nVdbeActive==0 ){
+ AtomicStore(&db->u1.isInterrupted, 0);
+ }
- assert( db->nVdbeWrite>0 || db->autoCommit==0
- || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
- );
+ assert( db->nVdbeWrite>0 || db->autoCommit==0
+ || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
+ );
#ifndef SQLITE_OMIT_TRACE
- if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0
- && !db->init.busy && p->zSql ){
- sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
- }else{
- assert( p->startTime==0 );
- }
+ if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0
+ && !db->init.busy && p->zSql ){
+ sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
+ }else{
+ assert( p->startTime==0 );
+ }
#endif
- db->nVdbeActive++;
- if( p->readOnly==0 ) db->nVdbeWrite++;
- if( p->bIsReader ) db->nVdbeRead++;
- p->pc = 0;
+ db->nVdbeActive++;
+ if( p->readOnly==0 ) db->nVdbeWrite++;
+ if( p->bIsReader ) db->nVdbeRead++;
+ p->pc = 0;
+ p->eVdbeState = VDBE_RUN_STATE;
+ }else
+
+ if( ALWAYS(p->eVdbeState==VDBE_HALT_STATE) ){
+ /* We used to require that sqlite3_reset() be called before retrying
+ ** sqlite3_step() after any error or after SQLITE_DONE. But beginning
+ ** with version 3.7.0, we changed this so that sqlite3_reset() would
+ ** be called automatically instead of throwing the SQLITE_MISUSE error.
+ ** This "automatic-reset" change is not technically an incompatibility,
+ ** since any application that receives an SQLITE_MISUSE is broken by
+ ** definition.
+ **
+ ** Nevertheless, some published applications that were originally written
+ ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
+ ** returns, and those were broken by the automatic-reset change. As a
+ ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
+ ** legacy behavior of returning SQLITE_MISUSE for cases where the
+ ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
+ ** or SQLITE_BUSY error.
+ */
+#ifdef SQLITE_OMIT_AUTORESET
+ if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
+ sqlite3_reset((sqlite3_stmt*)p);
+ }else{
+ return SQLITE_MISUSE_BKPT;
+ }
+#else
+ sqlite3_reset((sqlite3_stmt*)p);
+#endif
+ assert( p->eVdbeState==VDBE_READY_STATE );
+ goto restart_step;
+ }
}
+
#ifdef SQLITE_DEBUG
p->rcApp = SQLITE_OK;
#endif
@@ -717,7 +734,12 @@ static int sqlite3Step(Vdbe *p){
db->nVdbeExec--;
}
- if( rc!=SQLITE_ROW ){
+ if( rc==SQLITE_ROW ){
+ assert( p->rc==SQLITE_OK );
+ assert( db->mallocFailed==0 );
+ db->errCode = SQLITE_ROW;
+ return SQLITE_ROW;
+ }else{
#ifndef SQLITE_OMIT_TRACE
/* If the statement completed successfully, invoke the profile callback */
checkProfileCallback(db, p);
@@ -769,7 +791,6 @@ int sqlite3_step(sqlite3_stmt *pStmt){
}
db = v->db;
sqlite3_mutex_enter(db->mutex);
- v->doingRerun = 0;
while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
&& cnt++ < SQLITE_MAX_SCHEMA_RETRY ){
int savedPc = v->pc;
@@ -795,7 +816,13 @@ int sqlite3_step(sqlite3_stmt *pStmt){
break;
}
sqlite3_reset(pStmt);
- if( savedPc>=0 ) v->doingRerun = 1;
+ if( savedPc>=0 ){
+ /* Setting minWriteFileFormat to 254 is a signal to the OP_Init and
+ ** OP_Trace opcodes to *not* perform SQLITE_TRACE_STMT because one
+ ** should output has already occurred due to SQLITE_SCHEMA.
+ ** tag-20220401a */
+ v->minWriteFileFormat = 254;
+ }
assert( v->expired==0 );
}
sqlite3_mutex_leave(db->mutex);
@@ -1409,7 +1436,7 @@ static int vdbeUnbind(Vdbe *p, int i){
return SQLITE_MISUSE_BKPT;
}
sqlite3_mutex_enter(p->db->mutex);
- if( p->iVdbeMagic!=VDBE_MAGIC_RUN || p->pc>=0 ){
+ if( p->eVdbeState!=VDBE_READY_STATE ){
sqlite3Error(p->db, SQLITE_MISUSE);
sqlite3_mutex_leave(p->db->mutex);
sqlite3_log(SQLITE_MISUSE,
@@ -1762,7 +1789,7 @@ int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){
*/
int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
Vdbe *v = (Vdbe*)pStmt;
- return v!=0 && v->iVdbeMagic==VDBE_MAGIC_RUN && v->pc>=0;
+ return v!=0 && v->eVdbeState==VDBE_RUN_STATE;
}
/*
@@ -1808,8 +1835,7 @@ int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
sqlite3_mutex_enter(db->mutex);
v = 0;
db->pnBytesFreed = (int*)&v;
- sqlite3VdbeClearObject(db, pVdbe);
- sqlite3DbFree(db, pVdbe);
+ sqlite3VdbeDelete(pVdbe);
db->pnBytesFreed = 0;
sqlite3_mutex_leave(db->mutex);
}else{
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index aea932125c..9e702edcd5 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -35,7 +35,7 @@ Vdbe *sqlite3VdbeCreate(Parse *pParse){
p->pNext = db->pVdbe;
p->pPrev = 0;
db->pVdbe = p;
- p->iVdbeMagic = VDBE_MAGIC_INIT;
+ assert( p->eVdbeState==VDBE_INIT_STATE );
p->pParse = pParse;
pParse->pVdbe = p;
assert( pParse->aLabel==0 );
@@ -236,7 +236,7 @@ int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
VdbeOp *pOp;
i = p->nOp;
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( p->eVdbeState==VDBE_INIT_STATE );
assert( op>=0 && op<0xff );
if( p->nOpAlloc<=i ){
return growOp3(p, op, p1, p2, p3);
@@ -568,7 +568,7 @@ static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
void sqlite3VdbeResolveLabel(Vdbe *v, int x){
Parse *p = v->pParse;
int j = ADDR(x);
- assert( v->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( v->eVdbeState==VDBE_INIT_STATE );
assert( j<-p->nLabel );
assert( j>=0 );
#ifdef SQLITE_DEBUG
@@ -588,14 +588,20 @@ void sqlite3VdbeResolveLabel(Vdbe *v, int x){
** Mark the VDBE as one that can only be run one time.
*/
void sqlite3VdbeRunOnlyOnce(Vdbe *p){
- p->runOnlyOnce = 1;
+ sqlite3VdbeAddOp2(p, OP_Expire, 1, 1);
}
/*
** Mark the VDBE as one that can only be run multiple times.
*/
void sqlite3VdbeReusable(Vdbe *p){
- p->runOnlyOnce = 0;
+ int i;
+ for(i=1; ALWAYS(inOp); i++){
+ if( ALWAYS(p->aOp[i].opcode==OP_Expire) ){
+ p->aOp[1].opcode = OP_Noop;
+ break;
+ }
+ }
}
#ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
@@ -699,6 +705,8 @@ int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
int hasInitCoroutine = 0;
Op *pOp;
VdbeOpIter sIter;
+
+ if( v==0 ) return 0;
memset(&sIter, 0, sizeof(sIter));
sIter.v = v;
@@ -863,18 +871,104 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
if( pOp==p->aOp ) break;
pOp--;
}
- sqlite3DbFree(p->db, pParse->aLabel);
- pParse->aLabel = 0;
+ if( aLabel ){
+ sqlite3DbFreeNN(p->db, pParse->aLabel);
+ pParse->aLabel = 0;
+ }
pParse->nLabel = 0;
*pMaxFuncArgs = nMaxArgs;
assert( p->bIsReader!=0 || DbMaskAllZero(p->btreeMask) );
}
+#ifdef SQLITE_DEBUG
+/*
+** Check to see if a subroutine contains a jump to a location outside of
+** the subroutine. If a jump outside the subroutine is detected, add code
+** that will cause the program to halt with an error message.
+**
+** The subroutine consists of opcodes between iFirst and iLast. Jumps to
+** locations within the subroutine are acceptable. iRetReg is a register
+** that contains the return address. Jumps to outside the range of iFirst
+** through iLast are also acceptable as long as the jump destination is
+** an OP_Return to iReturnAddr.
+**
+** A jump to an unresolved label means that the jump destination will be
+** beyond the current address. That is normally a jump to an early
+** termination and is consider acceptable.
+**
+** This routine only runs during debug builds. The purpose is (of course)
+** to detect invalid escapes out of a subroutine. The OP_Halt opcode
+** is generated rather than an assert() or other error, so that ".eqp full"
+** will still work to show the original bytecode, to aid in debugging.
+*/
+void sqlite3VdbeNoJumpsOutsideSubrtn(
+ Vdbe *v, /* The byte-code program under construction */
+ int iFirst, /* First opcode of the subroutine */
+ int iLast, /* Last opcode of the subroutine */
+ int iRetReg /* Subroutine return address register */
+){
+ VdbeOp *pOp;
+ Parse *pParse;
+ int i;
+ sqlite3_str *pErr = 0;
+ assert( v!=0 );
+ pParse = v->pParse;
+ assert( pParse!=0 );
+ if( pParse->nErr ) return;
+ assert( iLast>=iFirst );
+ assert( iLastnOp );
+ pOp = &v->aOp[iFirst];
+ for(i=iFirst; i<=iLast; i++, pOp++){
+ if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 ){
+ int iDest = pOp->p2; /* Jump destination */
+ if( iDest==0 ) continue;
+ if( pOp->opcode==OP_Gosub ) continue;
+ if( iDest<0 ){
+ int j = ADDR(iDest);
+ assert( j>=0 );
+ if( j>=-pParse->nLabel || pParse->aLabel[j]<0 ){
+ continue;
+ }
+ iDest = pParse->aLabel[j];
+ }
+ if( iDestiLast ){
+ int j = iDest;
+ for(; jnOp; j++){
+ VdbeOp *pX = &v->aOp[j];
+ if( pX->opcode==OP_Return ){
+ if( pX->p1==iRetReg ) break;
+ continue;
+ }
+ if( pX->opcode==OP_Noop ) continue;
+ if( pX->opcode==OP_Explain ) continue;
+ if( pErr==0 ){
+ pErr = sqlite3_str_new(0);
+ }else{
+ sqlite3_str_appendchar(pErr, 1, '\n');
+ }
+ sqlite3_str_appendf(pErr,
+ "Opcode at %d jumps to %d which is outside the "
+ "subroutine at %d..%d",
+ i, iDest, iFirst, iLast);
+ break;
+ }
+ }
+ }
+ }
+ if( pErr ){
+ char *zErr = sqlite3_str_finish(pErr);
+ sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_INTERNAL, OE_Abort, 0, zErr, 0);
+ sqlite3_free(zErr);
+ sqlite3MayAbort(pParse);
+ }
+}
+#endif /* SQLITE_DEBUG */
+
/*
** Return the address of the next instruction to be inserted.
*/
int sqlite3VdbeCurrentAddr(Vdbe *p){
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( p->eVdbeState==VDBE_INIT_STATE );
return p->nOp;
}
@@ -959,7 +1053,7 @@ VdbeOp *sqlite3VdbeAddOpList(
int i;
VdbeOp *pOut, *pFirst;
assert( nOp>0 );
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( p->eVdbeState==VDBE_INIT_STATE );
if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
return 0;
}
@@ -1150,13 +1244,16 @@ static void freeP4(sqlite3 *db, int p4type, void *p4){
** nOp entries.
*/
static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
+ assert( nOp>=0 );
if( aOp ){
- Op *pOp;
- for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){
+ Op *pOp = &aOp[nOp-1];
+ while(1){ /* Exit via break */
if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
sqlite3DbFree(db, pOp->zComment);
#endif
+ if( pOp==aOp ) break;
+ pOp--;
}
sqlite3DbFreeNN(db, aOp);
}
@@ -1218,7 +1315,7 @@ void sqlite3VdbeReleaseRegisters(
u32 mask, /* Mask of registers to NOT release */
int bUndefine /* If true, mark registers as undefined */
){
- if( N==0 ) return;
+ if( N==0 || OptimizationDisabled(pParse->db, SQLITE_ReleaseReg) ) return;
assert( pParse->pVdbe );
assert( iFirst>=1 );
assert( iFirst+N-1<=pParse->nMem );
@@ -1282,7 +1379,7 @@ void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
sqlite3 *db;
assert( p!=0 );
db = p->db;
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( p->eVdbeState==VDBE_INIT_STATE );
assert( p->aOp!=0 || db->mallocFailed );
if( db->mallocFailed ){
if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
@@ -1410,7 +1507,7 @@ VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
/* C89 specifies that the constant "dummy" will be initialized to all
** zeros, which is correct. MSVC generates a warning, nevertheless. */
static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( p->eVdbeState==VDBE_INIT_STATE );
if( addr<0 ){
addr = p->nOp - 1;
}
@@ -1477,8 +1574,13 @@ char *sqlite3VdbeDisplayComment(
if( c=='4' ){
sqlite3_str_appendall(&x, zP4);
}else if( c=='X' ){
- sqlite3_str_appendall(&x, pOp->zComment);
+ if( pOp->zComment && pOp->zComment[0] ){
+ sqlite3_str_appendall(&x, pOp->zComment);
+ }else{
+ sqlite3_str_appendall(&x, zSynopsis+1);
+ }
seenCom = 1;
+ break;
}else{
int v1 = translateP(c, pOp);
int v2;
@@ -2073,7 +2175,7 @@ void sqlite3VdbeFrameDelete(VdbeFrame *p){
VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
assert( sqlite3VdbeFrameIsValid(p) );
for(i=0; inChildCsr; i++){
- sqlite3VdbeFreeCursor(p->v, apCsr[i]);
+ if( apCsr[i] ) sqlite3VdbeFreeCursorNN(p->v, apCsr[i]);
}
releaseMemArray(aMem, p->nChildMem);
sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0);
@@ -2112,7 +2214,7 @@ int sqlite3VdbeList(
Op *pOp; /* Current opcode */
assert( p->explain );
- assert( p->iVdbeMagic==VDBE_MAGIC_RUN );
+ assert( p->eVdbeState==VDBE_RUN_STATE );
assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
/* Even though this opcode does not use dynamic strings for
@@ -2267,11 +2369,11 @@ struct ReusableSpace {
static void *allocSpace(
struct ReusableSpace *p, /* Bulk memory available for allocation */
void *pBuf, /* Pointer to a prior allocation */
- sqlite3_int64 nByte /* Bytes of memory needed */
+ sqlite3_int64 nByte /* Bytes of memory needed. */
){
assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
if( pBuf==0 ){
- nByte = ROUND8(nByte);
+ nByte = ROUND8P(nByte);
if( nByte <= p->nFree ){
p->nFree -= nByte;
pBuf = &p->pSpace[p->nFree];
@@ -2292,14 +2394,15 @@ void sqlite3VdbeRewind(Vdbe *p){
int i;
#endif
assert( p!=0 );
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT || p->iVdbeMagic==VDBE_MAGIC_RESET );
+ assert( p->eVdbeState==VDBE_INIT_STATE
+ || p->eVdbeState==VDBE_READY_STATE
+ || p->eVdbeState==VDBE_HALT_STATE );
/* There should be at least one opcode.
*/
assert( p->nOp>0 );
- /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
- p->iVdbeMagic = VDBE_MAGIC_RUN;
+ p->eVdbeState = VDBE_READY_STATE;
#ifdef SQLITE_DEBUG
for(i=0; inMem; i++){
@@ -2355,7 +2458,7 @@ void sqlite3VdbeMakeReady(
assert( p!=0 );
assert( p->nOp>0 );
assert( pParse!=0 );
- assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
+ assert( p->eVdbeState==VDBE_INIT_STATE );
assert( pParse==p->pParse );
p->pVList = pParse->pVList;
pParse->pVList = 0;
@@ -2378,7 +2481,7 @@ void sqlite3VdbeMakeReady(
** opcode array. This extra memory will be reallocated for other elements
** of the prepared statement.
*/
- n = ROUND8(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */
+ n = ROUND8P(sizeof(Op)*p->nOp); /* Bytes of opcode memory used */
x.pSpace = &((u8*)p->aOp)[n]; /* Unused opcode memory */
assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) );
x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */
@@ -2466,9 +2569,9 @@ void sqlite3VdbeMakeReady(
** happens to hold.
*/
void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
- if( pCx==0 ){
- return;
- }
+ if( pCx ) sqlite3VdbeFreeCursorNN(p,pCx);
+}
+void sqlite3VdbeFreeCursorNN(Vdbe *p, VdbeCursor *pCx){
switch( pCx->eCurType ){
case CURTYPE_SORTER: {
sqlite3VdbeSorterClose(p->db, pCx);
@@ -2496,14 +2599,12 @@ void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
** Close all cursors in the current frame.
*/
static void closeCursorsInFrame(Vdbe *p){
- if( p->apCsr ){
- int i;
- for(i=0; inCursor; i++){
- VdbeCursor *pC = p->apCsr[i];
- if( pC ){
- sqlite3VdbeFreeCursor(p, pC);
- p->apCsr[i] = 0;
- }
+ int i;
+ for(i=0; inCursor; i++){
+ VdbeCursor *pC = p->apCsr[i];
+ if( pC ){
+ sqlite3VdbeFreeCursorNN(p, pC);
+ p->apCsr[i] = 0;
}
}
}
@@ -2552,9 +2653,7 @@ static void closeAllCursors(Vdbe *p){
}
assert( p->nFrame==0 );
closeCursorsInFrame(p);
- if( p->aMem ){
- releaseMemArray(p->aMem, p->nMem);
- }
+ releaseMemArray(p->aMem, p->nMem);
while( p->pDelFrame ){
VdbeFrame *pDel = p->pDelFrame;
p->pDelFrame = pDel->pParent;
@@ -2994,7 +3093,8 @@ int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
p->errorAction = OE_Abort;
sqlite3VdbeError(p, "FOREIGN KEY constraint failed");
- return SQLITE_ERROR;
+ if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ) return SQLITE_ERROR;
+ return SQLITE_CONSTRAINT_FOREIGNKEY;
}
return SQLITE_OK;
}
@@ -3033,9 +3133,7 @@ int sqlite3VdbeHalt(Vdbe *p){
** one, or the complete transaction if there is no statement transaction.
*/
- if( p->iVdbeMagic!=VDBE_MAGIC_RUN ){
- return SQLITE_OK;
- }
+ assert( p->eVdbeState==VDBE_RUN_STATE );
if( db->mallocFailed ){
p->rc = SQLITE_NOMEM_BKPT;
}
@@ -3044,7 +3142,7 @@ int sqlite3VdbeHalt(Vdbe *p){
/* No commit or rollback needed if the program never started or if the
** SQL statement does not read or write a database file. */
- if( p->pc>=0 && p->bIsReader ){
+ if( p->bIsReader ){
int mrc; /* Primary error code from p->rc */
int eStatementOp = 0;
int isSpecialError; /* Set to true if a 'special' error */
@@ -3192,15 +3290,13 @@ int sqlite3VdbeHalt(Vdbe *p){
}
/* We have successfully halted and closed the VM. Record this fact. */
- if( p->pc>=0 ){
- db->nVdbeActive--;
- if( !p->readOnly ) db->nVdbeWrite--;
- if( p->bIsReader ) db->nVdbeRead--;
- assert( db->nVdbeActive>=db->nVdbeRead );
- assert( db->nVdbeRead>=db->nVdbeWrite );
- assert( db->nVdbeWrite>=0 );
- }
- p->iVdbeMagic = VDBE_MAGIC_HALT;
+ db->nVdbeActive--;
+ if( !p->readOnly ) db->nVdbeWrite--;
+ if( p->bIsReader ) db->nVdbeRead--;
+ assert( db->nVdbeActive>=db->nVdbeRead );
+ assert( db->nVdbeRead>=db->nVdbeWrite );
+ assert( db->nVdbeWrite>=0 );
+ p->eVdbeState = VDBE_HALT_STATE;
checkActiveVdbeCnt(db);
if( db->mallocFailed ){
p->rc = SQLITE_NOMEM_BKPT;
@@ -3282,8 +3378,8 @@ static void vdbeInvokeSqllog(Vdbe *v){
** again.
**
** To look at it another way, this routine resets the state of the
-** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
-** VDBE_MAGIC_INIT.
+** virtual machine from VDBE_RUN_STATE or VDBE_HALT_STATE back to
+** VDBE_READY_STATE.
*/
int sqlite3VdbeReset(Vdbe *p){
#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
@@ -3297,7 +3393,7 @@ int sqlite3VdbeReset(Vdbe *p){
** error, then it might not have been halted properly. So halt
** it now.
*/
- sqlite3VdbeHalt(p);
+ if( p->eVdbeState==VDBE_RUN_STATE ) sqlite3VdbeHalt(p);
/* If the VDBE has been run even partially, then transfer the error code
** and error message from the VDBE into the main database structure. But
@@ -3311,13 +3407,6 @@ int sqlite3VdbeReset(Vdbe *p){
}else{
db->errCode = p->rc;
}
- if( p->runOnlyOnce ) p->expired = 1;
- }else if( p->rc && p->expired ){
- /* The expired flag was set on the VDBE before the first call
- ** to sqlite3_step(). For consistency (since sqlite3_step() was
- ** called), set the database error in this case as well.
- */
- sqlite3ErrorWithMsg(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
}
/* Reset register contents and reclaim error message memory.
@@ -3374,7 +3463,6 @@ int sqlite3VdbeReset(Vdbe *p){
}
}
#endif
- p->iVdbeMagic = VDBE_MAGIC_RESET;
return p->rc & db->errMask;
}
@@ -3384,7 +3472,10 @@ int sqlite3VdbeReset(Vdbe *p){
*/
int sqlite3VdbeFinalize(Vdbe *p){
int rc = SQLITE_OK;
- if( p->iVdbeMagic==VDBE_MAGIC_RUN || p->iVdbeMagic==VDBE_MAGIC_HALT ){
+ assert( VDBE_RUN_STATE>VDBE_READY_STATE );
+ assert( VDBE_HALT_STATE>VDBE_READY_STATE );
+ assert( VDBE_INIT_STATEeVdbeState>=VDBE_READY_STATE ){
rc = sqlite3VdbeReset(p);
assert( (rc & p->db->errMask)==rc );
}
@@ -3436,22 +3527,24 @@ void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){
** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
** the database connection and frees the object itself.
*/
-void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
+static void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
SubProgram *pSub, *pNext;
assert( p->db==0 || p->db==db );
- releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
+ if( p->aColName ){
+ releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
+ sqlite3DbFreeNN(db, p->aColName);
+ }
for(pSub=p->pProgram; pSub; pSub=pNext){
pNext = pSub->pNext;
vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
sqlite3DbFree(db, pSub);
}
- if( p->iVdbeMagic!=VDBE_MAGIC_INIT ){
+ if( p->eVdbeState!=VDBE_INIT_STATE ){
releaseMemArray(p->aVar, p->nVar);
- sqlite3DbFree(db, p->pVList);
- sqlite3DbFree(db, p->pFree);
+ if( p->pVList ) sqlite3DbFreeNN(db, p->pVList);
+ if( p->pFree ) sqlite3DbFreeNN(db, p->pFree);
}
vdbeFreeOpArray(db, p->aOp, p->nOp);
- sqlite3DbFree(db, p->aColName);
sqlite3DbFree(db, p->zSql);
#ifdef SQLITE_ENABLE_NORMALIZE
sqlite3DbFree(db, p->zNormSql);
@@ -3484,17 +3577,17 @@ void sqlite3VdbeDelete(Vdbe *p){
db = p->db;
assert( sqlite3_mutex_held(db->mutex) );
sqlite3VdbeClearObject(db, p);
- if( p->pPrev ){
- p->pPrev->pNext = p->pNext;
- }else{
- assert( db->pVdbe==p );
- db->pVdbe = p->pNext;
+ if( db->pnBytesFreed==0 ){
+ if( p->pPrev ){
+ p->pPrev->pNext = p->pNext;
+ }else{
+ assert( db->pVdbe==p );
+ db->pVdbe = p->pNext;
+ }
+ if( p->pNext ){
+ p->pNext->pPrev = p->pPrev;
+ }
}
- if( p->pNext ){
- p->pNext->pPrev = p->pPrev;
- }
- p->iVdbeMagic = VDBE_MAGIC_DEAD;
- p->db = 0;
sqlite3DbFreeNN(db, p);
}
@@ -3545,7 +3638,7 @@ int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p){
** if need be. Return any I/O error from the restore operation.
*/
int sqlite3VdbeCursorRestore(VdbeCursor *p){
- assert( p->eCurType==CURTYPE_BTREE );
+ assert( p->eCurType==CURTYPE_BTREE || IsNullCursor(p) );
if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
return sqlite3VdbeHandleMovedCursor(p);
}
@@ -3558,7 +3651,7 @@ int sqlite3VdbeCursorRestore(VdbeCursor *p){
** sqlite3VdbeSerialType()
** sqlite3VdbeSerialTypeLen()
** sqlite3VdbeSerialLen()
-** sqlite3VdbeSerialPut()
+** sqlite3VdbeSerialPut() <--- in-lined into OP_MakeRecord as of 2022-04-02
** sqlite3VdbeSerialGet()
**
** encapsulate the code that serializes values for storage in SQLite
@@ -3670,7 +3763,7 @@ u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){
/*
** The sizes for serial types less than 128
*/
-static const u8 sqlite3SmallTypeSizes[] = {
+const u8 sqlite3SmallTypeSizes[128] = {
/* 0 1 2 3 4 5 6 7 8 9 */
/* 0 */ 0, 1, 2, 3, 4, 6, 8, 8, 0, 0,
/* 10 */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
@@ -3739,7 +3832,7 @@ u8 sqlite3VdbeOneByteSerialTypeLen(u8 serial_type){
** so we trust him.
*/
#ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
-static u64 floatSwap(u64 in){
+u64 sqlite3FloatSwap(u64 in){
union {
u64 r;
u32 i[2];
@@ -3752,59 +3845,8 @@ static u64 floatSwap(u64 in){
u.i[1] = t;
return u.r;
}
-# define swapMixedEndianFloat(X) X = floatSwap(X)
-#else
-# define swapMixedEndianFloat(X)
-#endif
+#endif /* SQLITE_MIXED_ENDIAN_64BIT_FLOAT */
-/*
-** Write the serialized data blob for the value stored in pMem into
-** buf. It is assumed that the caller has allocated sufficient space.
-** Return the number of bytes written.
-**
-** nBuf is the amount of space left in buf[]. The caller is responsible
-** for allocating enough space to buf[] to hold the entire field, exclusive
-** of the pMem->u.nZero bytes for a MEM_Zero value.
-**
-** Return the number of bytes actually written into buf[]. The number
-** of bytes in the zero-filled tail is included in the return value only
-** if those bytes were zeroed in buf[].
-*/
-u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
- u32 len;
-
- /* Integer and Real */
- if( serial_type<=7 && serial_type>0 ){
- u64 v;
- u32 i;
- if( serial_type==7 ){
- assert( sizeof(v)==sizeof(pMem->u.r) );
- memcpy(&v, &pMem->u.r, sizeof(v));
- swapMixedEndianFloat(v);
- }else{
- v = pMem->u.i;
- }
- len = i = sqlite3SmallTypeSizes[serial_type];
- assert( i>0 );
- do{
- buf[--i] = (u8)(v&0xFF);
- v >>= 8;
- }while( i );
- return len;
- }
-
- /* String or blob */
- if( serial_type>=12 ){
- assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
- == (int)sqlite3VdbeSerialTypeLen(serial_type) );
- len = pMem->n;
- if( len>0 ) memcpy(buf, pMem->z, len);
- return len;
- }
-
- /* NULL or constants 0 or 1 */
- return 0;
-}
/* Input "x" is a sequence of unsigned characters that represent a
** big-endian integer. Return the equivalent native integer
@@ -3970,10 +4012,10 @@ UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(
){
UnpackedRecord *p; /* Unpacked record to return */
int nByte; /* Number of bytes required for *p */
- nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
+ nByte = ROUND8P(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
if( !p ) return 0;
- p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
+ p->aMem = (Mem*)&((char*)p)[ROUND8P(sizeof(UnpackedRecord))];
assert( pKeyInfo->aSortFlags!=0 );
p->pKeyInfo = pKeyInfo;
p->nField = pKeyInfo->nKeyField + 1;
@@ -4471,14 +4513,22 @@ int sqlite3VdbeRecordCompareWithSkip(
** two elements in the keys are equal. Fix the various stack variables so
** that this routine begins comparing at the second field. */
if( bSkip ){
- u32 s1;
- idx1 = 1 + getVarint32(&aKey1[1], s1);
+ u32 s1 = aKey1[1];
+ if( s1<0x80 ){
+ idx1 = 2;
+ }else{
+ idx1 = 1 + sqlite3GetVarint32(&aKey1[1], &s1);
+ }
szHdr1 = aKey1[0];
d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1);
i = 1;
pRhs++;
}else{
- idx1 = getVarint32(aKey1, szHdr1);
+ if( (szHdr1 = aKey1[0])<0x80 ){
+ idx1 = 1;
+ }else{
+ idx1 = sqlite3GetVarint32(aKey1, &szHdr1);
+ }
d1 = szHdr1;
i = 0;
}
diff --git a/src/vdbemem.c b/src/vdbemem.c
index 516a06b71e..faa35f0ac9 100644
--- a/src/vdbemem.c
+++ b/src/vdbemem.c
@@ -204,7 +204,11 @@ int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
assert( !sqlite3VdbeMemIsRowSet(pMem) );
assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
|| desiredEnc==SQLITE_UTF16BE );
- if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
+ if( !(pMem->flags&MEM_Str) ){
+ pMem->enc = desiredEnc;
+ return SQLITE_OK;
+ }
+ if( pMem->enc==desiredEnc ){
return SQLITE_OK;
}
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
@@ -453,9 +457,10 @@ int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
Mem t;
assert( pFunc!=0 );
assert( pMem!=0 );
+ assert( pMem->db!=0 );
assert( pFunc->xFinalize!=0 );
assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
- assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
+ assert( sqlite3_mutex_held(pMem->db->mutex) );
memset(&ctx, 0, sizeof(ctx));
memset(&t, 0, sizeof(t));
t.flags = MEM_Null;
@@ -463,6 +468,7 @@ int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
ctx.pOut = &t;
ctx.pMem = pMem;
ctx.pFunc = pFunc;
+ ctx.enc = ENC(t.db);
pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
assert( (pMem->flags & MEM_Dyn)==0 );
if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
@@ -484,12 +490,14 @@ int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
assert( pFunc!=0 );
assert( pFunc->xValue!=0 );
assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
- assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) );
+ assert( pAccum->db!=0 );
+ assert( sqlite3_mutex_held(pAccum->db->mutex) );
memset(&ctx, 0, sizeof(ctx));
sqlite3VdbeMemSetNull(pOut);
ctx.pOut = pOut;
ctx.pMem = pAccum;
ctx.pFunc = pFunc;
+ ctx.enc = ENC(pAccum->db);
pFunc->xValue(&ctx);
return ctx.isError;
}
@@ -1107,6 +1115,13 @@ void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
** stored without allocating memory, then it is. If a memory allocation
** is required to store the string, then value of pMem is unchanged. In
** either case, SQLITE_TOOBIG is returned.
+**
+** The "enc" parameter is the text encoding for the string, or zero
+** to store a blob.
+**
+** If n is negative, then the string consists of all bytes up to but
+** excluding the first zero character. The n parameter must be
+** non-negative for blobs.
*/
int sqlite3VdbeMemSetStr(
Mem *pMem, /* Memory cell to set to string value */
@@ -1117,11 +1132,12 @@ int sqlite3VdbeMemSetStr(
){
i64 nByte = n; /* New value for pMem->n */
int iLimit; /* Maximum allowed string or blob size */
- u16 flags = 0; /* New value for pMem->flags */
+ u16 flags; /* New value for pMem->flags */
assert( pMem!=0 );
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
assert( !sqlite3VdbeMemIsRowSet(pMem) );
+ assert( enc!=0 || n>=0 );
/* If z is a NULL pointer, set pMem to contain an SQL NULL. */
if( !z ){
@@ -1134,7 +1150,6 @@ int sqlite3VdbeMemSetStr(
}else{
iLimit = SQLITE_MAX_LENGTH;
}
- flags = (enc==0?MEM_Blob:MEM_Str);
if( nByte<0 ){
assert( enc!=0 );
if( enc==SQLITE_UTF8 ){
@@ -1142,7 +1157,23 @@ int sqlite3VdbeMemSetStr(
}else{
for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
}
- flags |= MEM_Term;
+ flags= MEM_Str|MEM_Term;
+ }else if( enc==0 ){
+ flags = MEM_Blob;
+ enc = SQLITE_UTF8;
+ }else{
+ flags = MEM_Str;
+ }
+ if( nByte>iLimit ){
+ if( xDel && xDel!=SQLITE_TRANSIENT ){
+ if( xDel==SQLITE_DYNAMIC ){
+ sqlite3DbFree(pMem->db, (void*)z);
+ }else{
+ xDel((void*)z);
+ }
+ }
+ sqlite3VdbeMemSetNull(pMem);
+ return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
}
/* The following block sets the new values of Mem.z and Mem.xDel. It
@@ -1154,9 +1185,6 @@ int sqlite3VdbeMemSetStr(
if( flags&MEM_Term ){
nAlloc += (enc==SQLITE_UTF8?1:2);
}
- if( nByte>iLimit ){
- return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
- }
testcase( nAlloc==0 );
testcase( nAlloc==31 );
testcase( nAlloc==32 );
@@ -1178,16 +1206,7 @@ int sqlite3VdbeMemSetStr(
pMem->n = (int)(nByte & 0x7fffffff);
pMem->flags = flags;
- if( enc ){
- pMem->enc = enc;
-#ifdef SQLITE_ENABLE_SESSION
- }else if( pMem->db==0 ){
- pMem->enc = SQLITE_UTF8;
-#endif
- }else{
- assert( pMem->db!=0 );
- pMem->enc = ENC(pMem->db);
- }
+ pMem->enc = enc;
#ifndef SQLITE_OMIT_UTF16
if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
@@ -1195,9 +1214,6 @@ int sqlite3VdbeMemSetStr(
}
#endif
- if( nByte>iLimit ){
- return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
- }
return SQLITE_OK;
}
@@ -1479,6 +1495,7 @@ static int valueFromFunction(
memset(&ctx, 0, sizeof(ctx));
ctx.pOut = pVal;
ctx.pFunc = pFunc;
+ ctx.enc = ENC(db);
pFunc->xSFunc(&ctx, nVal, apVal);
if( ctx.isError ){
rc = ctx.isError;
diff --git a/src/vtab.c b/src/vtab.c
index 11c076e4e6..b50ccd24a6 100644
--- a/src/vtab.c
+++ b/src/vtab.c
@@ -827,6 +827,7 @@ int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
sqlite3ParseObjectInit(&sParse, db);
sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
+ sParse.disableTriggers = 1;
/* We should never be able to reach this point while loading the
** schema. Nevertheless, defend against that (turn off db->init.busy)
** in case a bug arises. */
diff --git a/src/where.c b/src/where.c
index ca4ce3d805..a9c6db64e5 100644
--- a/src/where.c
+++ b/src/where.c
@@ -102,7 +102,7 @@ int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){
}
pInner = &pWInfo->a[pWInfo->nLevel-1];
assert( pInner->addrNxt!=0 );
- return pInner->addrNxt;
+ return pInner->pRJ ? pWInfo->iContinue : pInner->addrNxt;
}
/*
@@ -253,6 +253,30 @@ Bitmask sqlite3WhereGetMask(WhereMaskSet *pMaskSet, int iCursor){
return 0;
}
+/* Allocate memory that is automatically freed when pWInfo is freed.
+*/
+void *sqlite3WhereMalloc(WhereInfo *pWInfo, u64 nByte){
+ WhereMemBlock *pBlock;
+ pBlock = sqlite3DbMallocRawNN(pWInfo->pParse->db, nByte+sizeof(*pBlock));
+ if( pBlock ){
+ pBlock->pNext = pWInfo->pMemToFree;
+ pBlock->sz = nByte;
+ pWInfo->pMemToFree = pBlock;
+ pBlock++;
+ }
+ return (void*)pBlock;
+}
+void *sqlite3WhereRealloc(WhereInfo *pWInfo, void *pOld, u64 nByte){
+ void *pNew = sqlite3WhereMalloc(pWInfo, nByte);
+ if( pNew && pOld ){
+ WhereMemBlock *pOldBlk = (WhereMemBlock*)pOld;
+ pOldBlk--;
+ assert( pOldBlk->szsz);
+ }
+ return pNew;
+}
+
/*
** Create a new mask for cursor iCursor.
**
@@ -732,13 +756,13 @@ static int termCanDriveIndex(
char aff;
if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
- if( (pSrc->fg.jointype & JT_LEFT)
+ if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ))!=0
&& !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
&& (pTerm->eOperator & WO_IS)
){
/* Cannot use an IS term from the WHERE clause as an index driver for
- ** the RHS of a LEFT JOIN. Such a term can only be used if it is from
- ** the ON clause. */
+ ** the RHS of a LEFT JOIN or for the LHS of a RIGHT JOIN. Such a term
+ ** can only be used if it is from the ON clause. */
return 0;
}
if( (pTerm->prereqRight & notReady)!=0 ) return 0;
@@ -808,8 +832,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
** WHERE clause (or the ON clause of a LEFT join) that constrain which
** rows of the target table (pSrc) that can be used. */
if( (pTerm->wtFlags & TERM_VIRTUAL)==0
- && ((pSrc->fg.jointype&JT_LEFT)==0 || ExprHasProperty(pExpr,EP_FromJoin))
- && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor)
+ && sqlite3ExprIsTableConstraint(pExpr, pSrc)
){
pPartial = sqlite3ExprAnd(pParse, pPartial,
sqlite3ExprDup(pParse->db, pExpr, 0));
@@ -1048,7 +1071,7 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
for(pTerm=pWInfo->sWC.a; pTermpExpr;
if( (pTerm->wtFlags & TERM_VIRTUAL)==0
- && sqlite3ExprIsTableConstant(pExpr, iCur)
+ && sqlite3ExprIsTableConstraint(pExpr, pItem)
){
sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
}
@@ -1081,7 +1104,7 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
const SrcItem *pTabItem;
pLevel = &pWInfo->a[iLevel];
pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
- if( pTabItem->fg.jointype & JT_LEFT ) continue;
+ if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ) ) continue;
pLoop = pLevel->pWLoop;
if( NEVER(pLoop==0) ) continue;
if( pLoop->prereq & notReady ) continue;
@@ -1154,9 +1177,10 @@ static sqlite3_index_info *allocateIndexInfo(
assert( pTerm->u.x.leftColumnnCol );
/* tag-20191211-002: WHERE-clause constraints are not useful to the
- ** right-hand table of a LEFT JOIN. See tag-20191211-001 for the
+ ** right-hand table of a LEFT JOIN nor to the left-hand table of a
+ ** RIGHT JOIN. See tag-20191211-001 for the
** equivalent restriction for ordinary tables. */
- if( (pSrc->fg.jointype & JT_LEFT)!=0
+ if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ))!=0
&& !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
){
continue;
@@ -1182,7 +1206,7 @@ static sqlite3_index_info *allocateIndexInfo(
}
/* Virtual tables are unable to deal with NULLS FIRST */
- if( pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL ) break;
+ if( pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) break;
/* First case - a direct column references without a COLLATE operator */
if( pExpr->op==TK_COLUMN && pExpr->iTable==pSrc->iCursor ){
@@ -1212,8 +1236,10 @@ static sqlite3_index_info *allocateIndexInfo(
}
if( i==n ){
nOrderBy = n;
- if( (pWInfo->wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY)) ){
- eDistinct = 1 + ((pWInfo->wctrlFlags & WHERE_DISTINCTBY)!=0);
+ if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY) ){
+ eDistinct = 2 + ((pWInfo->wctrlFlags & WHERE_SORTBYGROUP)!=0);
+ }else if( pWInfo->wctrlFlags & WHERE_GROUPBY ){
+ eDistinct = 1;
}
}
}
@@ -1292,7 +1318,7 @@ static sqlite3_index_info *allocateIndexInfo(
|| (pExpr->op==TK_COLLATE && pExpr->pLeft->op==TK_COLUMN
&& pExpr->iColumn==pExpr->pLeft->iColumn) );
pIdxOrderBy[j].iColumn = pExpr->iColumn;
- pIdxOrderBy[j].desc = pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC;
+ pIdxOrderBy[j].desc = pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC;
j++;
}
pIdxInfo->nOrderBy = j;
@@ -2214,15 +2240,7 @@ static void whereLoopDelete(sqlite3 *db, WhereLoop *p){
** Free a WhereInfo structure
*/
static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
- int i;
assert( pWInfo!=0 );
- for(i=0; inLevel; i++){
- WhereLevel *pLevel = &pWInfo->a[i];
- if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE)!=0 ){
- assert( (pLevel->pWLoop->wsFlags & WHERE_MULTI_OR)==0 );
- sqlite3DbFree(db, pLevel->u.in.aInLoop);
- }
- }
sqlite3WhereClauseClear(&pWInfo->sWC);
while( pWInfo->pLoops ){
WhereLoop *p = pWInfo->pLoops;
@@ -2230,6 +2248,11 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
whereLoopDelete(db, p);
}
assert( pWInfo->pExprMods==0 );
+ while( pWInfo->pMemToFree ){
+ WhereMemBlock *pNext = pWInfo->pMemToFree->pNext;
+ sqlite3DbFreeNN(db, pWInfo->pMemToFree);
+ pWInfo->pMemToFree = pNext;
+ }
sqlite3DbFreeNN(db, pWInfo);
}
@@ -2594,8 +2617,18 @@ static void whereLoopOutputAdjust(
/* If there are extra terms in the WHERE clause not used by an index
** that depend only on the table being scanned, and that will tend to
** cause many rows to be omitted, then mark that table as
- ** "self-culling". */
- pLoop->wsFlags |= WHERE_SELFCULL;
+ ** "self-culling".
+ **
+ ** 2022-03-24: Self-culling only applies if either the extra terms
+ ** are straight comparison operators that are non-true with NULL
+ ** operand, or if the loop is not an OUTER JOIN.
+ */
+ if( (pTerm->eOperator & 0x3f)!=0
+ || (pWC->pWInfo->pTabList->a[pLoop->iTab].fg.jointype
+ & (JT_LEFT|JT_LTORJ))==0
+ ){
+ pLoop->wsFlags |= WHERE_SELFCULL;
+ }
}
if( pTerm->truthProb<=0 ){
/* If a truth probability is specified using the likelihood() hints,
@@ -2799,10 +2832,11 @@ static int whereLoopAddBtreeIndex(
if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue;
/* tag-20191211-001: Do not allow constraints from the WHERE clause to
- ** be used by the right table of a LEFT JOIN. Only constraints in the
+ ** be used by the right table of a LEFT JOIN nor by the left table of a
+ ** RIGHT JOIN. Only constraints in the
** ON clause are allowed. See tag-20191211-002 for the vtab equivalent. */
- if( (pSrc->fg.jointype & JT_LEFT)!=0
- && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
+ if( (pSrc->fg.jointype & (JT_LEFT|JT_LTORJ))!=0
+ && !ExprHasProperty(pTerm->pExpr, EP_FromJoin|EP_InnerJoin)
){
continue;
}
@@ -3171,7 +3205,7 @@ static int whereUsablePartialIndex(
for(i=0, pTerm=pWC->a; inTerm; i++, pTerm++){
Expr *pExpr;
pExpr = pTerm->pExpr;
- if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->w.iRightJoinTable==iTab)
+ if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->w.iJoin==iTab)
&& (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
&& sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
&& (pTerm->wtFlags & TERM_VNULL)==0
@@ -3281,13 +3315,14 @@ static int whereLoopAddBtree(
#ifndef SQLITE_OMIT_AUTOMATIC_INDEX
/* Automatic indexes */
if( !pBuilder->pOrSet /* Not part of an OR optimization */
- && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
+ && (pWInfo->wctrlFlags & (WHERE_RIGHT_JOIN|WHERE_OR_SUBCLAUSE))==0
&& (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
&& !pSrc->fg.isIndexedBy /* Has no INDEXED BY clause */
&& !pSrc->fg.notIndexed /* Has no NOT INDEXED clause */
&& HasRowid(pTab) /* Not WITHOUT ROWID table. (FIXME: Why not?) */
&& !pSrc->fg.isCorrelated /* Not a correlated subquery */
&& !pSrc->fg.isRecursive /* Not a recursive common table expression. */
+ && (pSrc->fg.jointype & JT_RIGHT)==0 /* Not the right tab of a RIGHT JOIN */
){
/* Generate auto-index WhereLoops */
LogEst rLogSize; /* Logarithm of the number of rows in the table */
@@ -3769,9 +3804,7 @@ int sqlite3_vtab_rhs_value(
*/
int sqlite3_vtab_distinct(sqlite3_index_info *pIdxInfo){
HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
- assert( pHidden->eDistinct==0
- || pHidden->eDistinct==1
- || pHidden->eDistinct==2 );
+ assert( pHidden->eDistinct>=0 && pHidden->eDistinct<=3 );
return pHidden->eDistinct;
}
@@ -3779,15 +3812,26 @@ int sqlite3_vtab_distinct(sqlite3_index_info *pIdxInfo){
&& !defined(SQLITE_OMIT_VIRTUALTABLE)
/*
** Cause the prepared statement that is associated with a call to
-** xBestIndex to open write transactions on all attached schemas.
+** xBestIndex to potentiall use all schemas. If the statement being
+** prepared is read-only, then just start read transactions on all
+** schemas. But if this is a write operation, start writes on all
+** schemas.
+**
** This is used by the (built-in) sqlite_dbpage virtual table.
*/
-void sqlite3VtabWriteAll(sqlite3_index_info *pIdxInfo){
+void sqlite3VtabUsesAllSchemas(sqlite3_index_info *pIdxInfo){
HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
Parse *pParse = pHidden->pParse;
int nDb = pParse->db->nDb;
int i;
- for(i=0; iwriteMask ){
+ for(i=0; ipTabList->a + pNew->iTab;
iCur = pItem->iCursor;
+ /* The multi-index OR optimization does not work for RIGHT and FULL JOIN */
+ if( pItem->fg.jointype & JT_RIGHT ) return SQLITE_OK;
+
for(pTerm=pWC->a; pTermeOperator & WO_OR)!=0
&& (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0
@@ -4094,18 +4141,16 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
pNew->iTab = iTab;
pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR;
pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor);
- if( (pItem->fg.jointype & (JT_LEFT|JT_CROSS))!=0 ){
+ if( (pItem->fg.jointype & (JT_OUTER|JT_CROSS))!=0 ){
/* This condition is true when pItem is the FROM clause term on the
- ** right-hand-side of a LEFT or CROSS JOIN. */
- mPrereq = mPrior;
- }else{
- mPrereq = 0;
+ ** right-hand-side of a OUTER or CROSS JOIN. */
+ mPrereq |= mPrior;
}
#ifndef SQLITE_OMIT_VIRTUALTABLE
if( IsVirtual(pItem->pTab) ){
SrcItem *p;
for(p=&pItem[1]; pfg.jointype & (JT_LEFT|JT_CROSS)) ){
+ if( mUnusable || (p->fg.jointype & (JT_OUTER|JT_CROSS)) ){
mUnusable |= sqlite3WhereGetMask(&pWInfo->sMaskSet, p->iCursor);
}
}
@@ -4230,7 +4275,9 @@ static i8 wherePathSatisfiesOrderBy(
pLoop = pLast;
}
if( pLoop->wsFlags & WHERE_VIRTUALTABLE ){
- if( pLoop->u.vtab.isOrdered && (wctrlFlags & WHERE_DISTINCTBY)==0 ){
+ if( pLoop->u.vtab.isOrdered
+ && ((wctrlFlags&(WHERE_DISTINCTBY|WHERE_SORTBYGROUP))!=WHERE_DISTINCTBY)
+ ){
obSat = obDone;
}
break;
@@ -4408,16 +4455,18 @@ static i8 wherePathSatisfiesOrderBy(
/* Make sure the sort order is compatible in an ORDER BY clause.
** Sort order is irrelevant for a GROUP BY clause. */
if( revSet ){
- if( (rev ^ revIdx)!=(pOrderBy->a[i].sortFlags&KEYINFO_ORDER_DESC) ){
+ if( (rev ^ revIdx)
+ != (pOrderBy->a[i].fg.sortFlags&KEYINFO_ORDER_DESC)
+ ){
isMatch = 0;
}
}else{
- rev = revIdx ^ (pOrderBy->a[i].sortFlags & KEYINFO_ORDER_DESC);
+ rev = revIdx ^ (pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_DESC);
if( rev ) *pRevMask |= MASKBIT(iLoop);
revSet = 1;
}
}
- if( isMatch && (pOrderBy->a[i].sortFlags & KEYINFO_ORDER_BIGNULL) ){
+ if( isMatch && (pOrderBy->a[i].fg.sortFlags & KEYINFO_ORDER_BIGNULL) ){
if( j==pLoop->u.btree.nEq ){
pLoop->wsFlags |= WHERE_BIGNULL_SORT;
}else{
@@ -4497,7 +4546,7 @@ static i8 wherePathSatisfiesOrderBy(
** SELECT * FROM t1 GROUP BY y,x ORDER BY y,x; -- IsSorted()==0
*/
int sqlite3WhereIsSorted(WhereInfo *pWInfo){
- assert( pWInfo->wctrlFlags & WHERE_GROUPBY );
+ assert( pWInfo->wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY) );
assert( pWInfo->wctrlFlags & WHERE_SORTBYGROUP );
return pWInfo->sorted;
}
@@ -4898,12 +4947,12 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
}
pWInfo->bOrderedInnerLoop = 0;
if( pWInfo->pOrderBy ){
+ pWInfo->nOBSat = pFrom->isOrdered;
if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
}
}else{
- pWInfo->nOBSat = pFrom->isOrdered;
pWInfo->revMask = pFrom->revLoop;
if( pWInfo->nOBSat<=0 ){
pWInfo->nOBSat = 0;
@@ -5166,7 +5215,7 @@ static SQLITE_NOINLINE Bitmask whereOmitNoopJoin(
for(pTerm=pWInfo->sWC.a; pTermprereqAll & pLoop->maskSelf)!=0 ){
if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
- || pTerm->pExpr->w.iRightJoinTable!=pItem->iCursor
+ || pTerm->pExpr->w.iJoin!=pItem->iCursor
){
break;
}
@@ -5397,7 +5446,7 @@ WhereInfo *sqlite3WhereBegin(
** field (type Bitmask) it must be aligned on an 8-byte boundary on
** some architectures. Hence the ROUND8() below.
*/
- nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel));
+ nByteWInfo = ROUND8P(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel));
pWInfo = sqlite3DbMallocRawNN(db, nByteWInfo + sizeof(WhereLoop));
if( db->mallocFailed ){
sqlite3DbFree(db, pWInfo);
@@ -5719,8 +5768,10 @@ WhereInfo *sqlite3WhereBegin(
/* noop */
}else
#endif
- if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
- && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){
+ if( ((pLoop->wsFlags & WHERE_IDX_ONLY)==0
+ && (wctrlFlags & WHERE_OR_SUBCLAUSE)==0)
+ || (pTabItem->fg.jointype & (JT_LTORJ|JT_RIGHT))!=0
+ ){
int op = OP_OpenRead;
if( pWInfo->eOnePass!=ONEPASS_OFF ){
op = OP_OpenWrite;
@@ -5822,6 +5873,37 @@ WhereInfo *sqlite3WhereBegin(
}
}
if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
+ if( (pTabItem->fg.jointype & JT_RIGHT)!=0
+ && (pLevel->pRJ = sqlite3WhereMalloc(pWInfo, sizeof(WhereRightJoin)))!=0
+ ){
+ WhereRightJoin *pRJ = pLevel->pRJ;
+ pRJ->iMatch = pParse->nTab++;
+ pRJ->regBloom = ++pParse->nMem;
+ sqlite3VdbeAddOp2(v, OP_Blob, 65536, pRJ->regBloom);
+ pRJ->regReturn = ++pParse->nMem;
+ sqlite3VdbeAddOp2(v, OP_Null, 0, pRJ->regReturn);
+ assert( pTab==pTabItem->pTab );
+ if( HasRowid(pTab) ){
+ KeyInfo *pInfo;
+ sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, 1);
+ pInfo = sqlite3KeyInfoAlloc(pParse->db, 1, 0);
+ if( pInfo ){
+ pInfo->aColl[0] = 0;
+ pInfo->aSortFlags[0] = 0;
+ sqlite3VdbeAppendP4(v, pInfo, P4_KEYINFO);
+ }
+ }else{
+ Index *pPk = sqlite3PrimaryKeyIndex(pTab);
+ sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, pPk->nKeyCol);
+ sqlite3VdbeSetP4KeyInfo(pParse, pPk);
+ }
+ pLoop->wsFlags &= ~WHERE_IDX_ONLY;
+ /* The nature of RIGHT JOIN processing is such that it messes up
+ ** the output order. So omit any ORDER BY/GROUP BY elimination
+ ** optimizations. We need to do an actual sort for RIGHT JOIN. */
+ pWInfo->nOBSat = 0;
+ pWInfo->eDistinct = WHERE_DISTINCT_UNORDERED;
+ }
}
pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
if( db->mallocFailed ) goto whereBeginError;
@@ -5894,6 +5976,26 @@ whereBeginError:
}
#endif
+#ifdef SQLITE_DEBUG
+/*
+** Return true if cursor iCur is opened by instruction k of the
+** bytecode. Used inside of assert() only.
+*/
+static int cursorIsOpen(Vdbe *v, int iCur, int k){
+ while( k>=0 ){
+ VdbeOp *pOp = sqlite3VdbeGetOp(v,k--);
+ if( pOp->p1!=iCur ) continue;
+ if( pOp->opcode==OP_Close ) return 0;
+ if( pOp->opcode==OP_OpenRead ) return 1;
+ if( pOp->opcode==OP_OpenWrite ) return 1;
+ if( pOp->opcode==OP_OpenDup ) return 1;
+ if( pOp->opcode==OP_OpenAutoindex ) return 1;
+ if( pOp->opcode==OP_OpenEphemeral ) return 1;
+ }
+ return 0;
+}
+#endif /* SQLITE_DEBUG */
+
/*
** Generate the end of the WHERE loop. See comments on
** sqlite3WhereBegin() for additional information.
@@ -5914,6 +6016,18 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
for(i=pWInfo->nLevel-1; i>=0; i--){
int addr;
pLevel = &pWInfo->a[i];
+ if( pLevel->pRJ ){
+ /* Terminate the subroutine that forms the interior of the loop of
+ ** the RIGHT JOIN table */
+ WhereRightJoin *pRJ = pLevel->pRJ;
+ sqlite3VdbeResolveLabel(v, pLevel->addrCont);
+ pLevel->addrCont = 0;
+ pRJ->endSubrtn = sqlite3VdbeCurrentAddr(v);
+ sqlite3VdbeAddOp3(v, OP_Return, pRJ->regReturn, pRJ->addrSubrtn, 1);
+ VdbeCoverage(v);
+ assert( pParse->withinRJSubrtn>0 );
+ pParse->withinRJSubrtn--;
+ }
pLoop = pLevel->pWLoop;
if( pLevel->op!=OP_Noop ){
#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT
@@ -5941,7 +6055,7 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
}
#endif /* SQLITE_DISABLE_SKIPAHEAD_DISTINCT */
/* The common case: Advance to the next row */
- sqlite3VdbeResolveLabel(v, pLevel->addrCont);
+ if( pLevel->addrCont ) sqlite3VdbeResolveLabel(v, pLevel->addrCont);
sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
sqlite3VdbeChangeP5(v, pLevel->p5);
VdbeCoverage(v);
@@ -5956,7 +6070,7 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
#ifndef SQLITE_DISABLE_SKIPAHEAD_DISTINCT
if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek);
#endif
- }else{
+ }else if( pLevel->addrCont ){
sqlite3VdbeResolveLabel(v, pLevel->addrCont);
}
if( (pLoop->wsFlags & WHERE_IN_ABLE)!=0 && pLevel->u.in.nIn>0 ){
@@ -6006,6 +6120,10 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
}
}
sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
+ if( pLevel->pRJ ){
+ sqlite3VdbeAddOp3(v, OP_Return, pLevel->pRJ->regReturn, 0, 1);
+ VdbeCoverage(v);
+ }
if( pLevel->addrSkip ){
sqlite3VdbeGoto(v, pLevel->addrSkip);
VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
@@ -6049,11 +6167,6 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
}
- /* The "break" point is here, just past the end of the outer loop.
- ** Set it.
- */
- sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
-
assert( pWInfo->nLevel<=pTabList->nSrc );
for(i=0, pLevel=pWInfo->a; inLevel; i++, pLevel++){
int k, last;
@@ -6064,6 +6177,15 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
assert( pTab!=0 );
pLoop = pLevel->pWLoop;
+ /* Do RIGHT JOIN processing. Generate code that will output the
+ ** unmatched rows of the right operand of the RIGHT JOIN with
+ ** all of the columns of the left operand set to NULL.
+ */
+ if( pLevel->pRJ ){
+ sqlite3WhereRightJoinLoop(pWInfo, i, pLevel);
+ continue;
+ }
+
/* For a co-routine, change all OP_Column references to the table of
** the co-routine into OP_Copy of result contained in a register.
** OP_Rowid becomes OP_Null.
@@ -6075,29 +6197,6 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
continue;
}
-#ifdef SQLITE_ENABLE_EARLY_CURSOR_CLOSE
- /* Close all of the cursors that were opened by sqlite3WhereBegin.
- ** Except, do not close cursors that will be reused by the OR optimization
- ** (WHERE_OR_SUBCLAUSE). And do not close the OP_OpenWrite cursors
- ** created for the ONEPASS optimization.
- */
- if( (pTab->tabFlags & TF_Ephemeral)==0
- && !IsView(pTab)
- && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
- ){
- int ws = pLoop->wsFlags;
- if( pWInfo->eOnePass==ONEPASS_OFF && (ws & WHERE_IDX_ONLY)==0 ){
- sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
- }
- if( (ws & WHERE_INDEXED)!=0
- && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0
- && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1]
- ){
- sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
- }
- }
-#endif
-
/* If this scan uses an index, make VDBE code substitutions to read data
** from the index instead of from the table where possible. In some cases
** this optimization prevents the table from ever being read, which can
@@ -6146,14 +6245,15 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
){
int x = pOp->p2;
assert( pIdx->pTable==pTab );
+#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
+ if( pOp->opcode==OP_Offset ){
+ /* Do not need to translate the column number */
+ }else
+#endif
if( !HasRowid(pTab) ){
Index *pPk = sqlite3PrimaryKeyIndex(pTab);
x = pPk->aiColumn[x];
assert( x>=0 );
-#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
- }else if( pOp->opcode==OP_Offset ){
- /* Do not need to translate the column number */
-#endif
}else{
testcase( x!=sqlite3StorageColumnToTable(pTab,x) );
x = sqlite3StorageColumnToTable(pTab,x);
@@ -6163,9 +6263,22 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
pOp->p2 = x;
pOp->p1 = pLevel->iIdxCur;
OpcodeRewriteTrace(db, k, pOp);
+ }else{
+ /* Unable to translate the table reference into an index
+ ** reference. Verify that this is harmless - that the
+ ** table being referenced really is open.
+ */
+#ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
+ assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
+ || cursorIsOpen(v,pOp->p1,k)
+ || pOp->opcode==OP_Offset
+ );
+#else
+ assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
+ || cursorIsOpen(v,pOp->p1,k)
+ );
+#endif
}
- assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0
- || pWInfo->eOnePass );
}else if( pOp->opcode==OP_Rowid ){
pOp->p1 = pLevel->iIdxCur;
pOp->opcode = OP_IdxRowid;
@@ -6184,6 +6297,11 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
}
}
+ /* The "break" point is here, just past the end of the outer loop.
+ ** Set it.
+ */
+ sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
+
/* Final cleanup
*/
if( pWInfo->pExprMods ) whereUndoExprMods(pWInfo);
diff --git a/src/whereInt.h b/src/whereInt.h
index 3fc39f6b4a..93ab937c88 100644
--- a/src/whereInt.h
+++ b/src/whereInt.h
@@ -32,6 +32,28 @@ typedef struct WhereLoopBuilder WhereLoopBuilder;
typedef struct WhereScan WhereScan;
typedef struct WhereOrCost WhereOrCost;
typedef struct WhereOrSet WhereOrSet;
+typedef struct WhereMemBlock WhereMemBlock;
+typedef struct WhereRightJoin WhereRightJoin;
+
+/*
+** This object is a header on a block of allocated memory that will be
+** automatically freed when its WInfo oject is destructed.
+*/
+struct WhereMemBlock {
+ WhereMemBlock *pNext; /* Next block in the chain */
+ u8 sz; /* Bytes of space */
+};
+
+/*
+** Extra information attached to a WhereLevel that is a RIGHT JOIN.
+*/
+struct WhereRightJoin {
+ int iMatch; /* Cursor used to determine prior matched rows */
+ int regBloom; /* Bloom filter for iRJMatch */
+ int regReturn; /* Return register for the interior subroutine */
+ int addrSubrtn; /* Starting address for the interior subroutine */
+ int endSubrtn; /* The last opcode in the interior subroutine */
+};
/*
** This object contains information needed to implement a single nested
@@ -65,6 +87,7 @@ struct WhereLevel {
int addrLikeRep; /* LIKE range processing address */
#endif
int regFilter; /* Bloom filter */
+ WhereRightJoin *pRJ; /* Extra information for RIGHT JOIN */
u8 iFrom; /* Which entry in the FROM clause */
u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */
int p1, p2; /* Operands of the opcode used to end the loop */
@@ -478,6 +501,7 @@ struct WhereInfo {
int iEndWhere; /* End of the WHERE clause itself */
WhereLoop *pLoops; /* List of all WhereLoop objects */
WhereExprMod *pExprMods; /* Expression modifications */
+ WhereMemBlock *pMemToFree;/* Memory to free when this object destroyed */
Bitmask revMask; /* Mask of ORDER BY terms that need reversing */
WhereClause sWC; /* Decomposition of the WHERE clause */
WhereMaskSet sMaskSet; /* Map cursor numbers to bitmasks */
@@ -503,6 +527,8 @@ WhereTerm *sqlite3WhereFindTerm(
u32 op, /* Mask of WO_xx values describing operator */
Index *pIdx /* Must be compatible with this index, if not NULL */
);
+void *sqlite3WhereMalloc(WhereInfo *pWInfo, u64 nByte);
+void *sqlite3WhereRealloc(WhereInfo *pWInfo, void *pOld, u64 nByte);
/* wherecode.c: */
#ifndef SQLITE_OMIT_EXPLAIN
@@ -539,6 +565,11 @@ Bitmask sqlite3WhereCodeOneLoopStart(
WhereLevel *pLevel, /* The current level pointer */
Bitmask notReady /* Which tables are currently available */
);
+SQLITE_NOINLINE void sqlite3WhereRightJoinLoop(
+ WhereInfo *pWInfo,
+ int iLevel,
+ WhereLevel *pLevel
+);
/* whereexpr.c: */
void sqlite3WhereClauseInit(WhereClause*,WhereInfo*);
diff --git a/src/wherecode.c b/src/wherecode.c
index ce0279a8f6..a942e6e7fb 100644
--- a/src/wherecode.c
+++ b/src/wherecode.c
@@ -204,6 +204,9 @@ int sqlite3WhereExplainOneScan(
pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
}
#endif
+ if( pItem->fg.jointype & JT_LEFT ){
+ sqlite3_str_appendf(&str, " LEFT-JOIN");
+ }
#ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS
if( pLoop->nOut>=10 ){
sqlite3_str_appendf(&str, " (~%llu rows)",
@@ -608,16 +611,22 @@ static int codeEqualityTerm(
if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
}else{
- sqlite3 *db = pParse->db;
- pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
-
- if( !db->mallocFailed ){
+ Expr *pExpr = pTerm->pExpr;
+ if( pExpr->iTable==0 || !ExprHasProperty(pExpr, EP_Subrtn) ){
+ sqlite3 *db = pParse->db;
+ pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
+ if( !db->mallocFailed ){
+ aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
+ eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap,&iTab);
+ pExpr->iTable = iTab;
+ }
+ sqlite3ExprDelete(db, pX);
+ }else{
aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
- eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
- pTerm->pExpr->iTable = iTab;
+ eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP|IN_INDEX_REUSE_CUR, 0, aiMap,&iTab);
+ iTab = pExpr->iTable;
}
- sqlite3ExprDelete(db, pX);
- pX = pTerm->pExpr;
+ pX = pExpr;
}
if( eType==IN_INDEX_INDEX_DESC ){
@@ -640,8 +649,9 @@ static int codeEqualityTerm(
i = pLevel->u.in.nIn;
pLevel->u.in.nIn += nEq;
pLevel->u.in.aInLoop =
- sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
- sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
+ sqlite3WhereRealloc(pTerm->pWC->pWInfo,
+ pLevel->u.in.aInLoop,
+ sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
pIn = pLevel->u.in.aInLoop;
if( pIn ){
int iMap = 0; /* Index in aiMap[] */
@@ -1063,7 +1073,7 @@ static void codeCursorHint(
if( pTabItem->fg.jointype & JT_LEFT ){
Expr *pExpr = pTerm->pExpr;
if( !ExprHasProperty(pExpr, EP_FromJoin)
- || pExpr->w.iRightJoinTable!=pTabItem->iCursor
+ || pExpr->w.iJoin!=pTabItem->iCursor
){
sWalker.eCode = 0;
sWalker.xExprCallback = codeCursorHintIsOrFunction;
@@ -1149,7 +1159,7 @@ static void codeDeferredSeek(
pWInfo->bDeferredSeek = 1;
sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
- if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
+ if( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))
&& DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
){
int i;
@@ -1243,12 +1253,12 @@ static void preserveExpr(IdxExprTrans *pTrans, Expr *pExpr){
static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
IdxExprTrans *pX = p->u.pIdxTrans;
if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
+ pExpr = sqlite3ExprSkipCollate(pExpr);
preserveExpr(pX, pExpr);
pExpr->affExpr = sqlite3ExprAffinity(pExpr);
pExpr->op = TK_COLUMN;
pExpr->iTable = pX->iIdxCur;
pExpr->iColumn = pX->iIdxCol;
- testcase( ExprHasProperty(pExpr, EP_Skip) );
testcase( ExprHasProperty(pExpr, EP_Unlikely) );
ExprClearProperty(pExpr, EP_Skip|EP_Unlikely|EP_WinFunc|EP_Subrtn);
pExpr->y.pTab = 0;
@@ -1402,6 +1412,8 @@ static SQLITE_NOINLINE void filterPullDown(
/* ,--- Because sqlite3ConstructBloomFilter() has will not have set
** vvvvv--' pLevel->regFilter if this were true. */
if( NEVER(pLoop->prereq & notReady) ) continue;
+ assert( pLevel->addrBrk==0 );
+ pLevel->addrBrk = addrNxt;
if( pLoop->wsFlags & WHERE_IPK ){
WhereTerm *pTerm = pLoop->aLTerm[0];
int regRowid;
@@ -1428,6 +1440,7 @@ static SQLITE_NOINLINE void filterPullDown(
VdbeCoverage(pParse->pVdbe);
}
pLevel->regFilter = 0;
+ pLevel->addrBrk = 0;
}
}
@@ -1501,7 +1514,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
** initialize a memory cell that records if this table matches any
** row of the left table of the join.
*/
- assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
+ assert( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))
|| pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0
);
if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
@@ -1512,7 +1525,10 @@ Bitmask sqlite3WhereCodeOneLoopStart(
/* Compute a safe address to jump to if we discover that the table for
** this loop is empty and can never contribute content. */
- for(j=iLevel; j>0 && pWInfo->a[j].iLeftJoin==0; j--){}
+ for(j=iLevel; j>0; j--){
+ if( pWInfo->a[j].iLeftJoin ) break;
+ if( pWInfo->a[j].pRJ ) break;
+ }
addrHalt = pWInfo->a[j].addrBrk;
/* Special case of a FROM clause subquery implemented as a co-routine */
@@ -2139,7 +2155,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
/* Seek the table cursor, if required */
omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0
- && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0;
+ && (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0;
if( omitTable ){
/* pIdx is a covering index. No need to access the main table. */
}else if( HasRowid(pIdx->pTable) ){
@@ -2173,7 +2189,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
** move forward to the next index.
** https://sqlite.org/src/info/4e8e4857d32d401f
*/
- if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 ){
+ if( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0 ){
whereIndexExprTrans(pIdx, iCur, iIdxCur, pWInfo);
}
@@ -2192,7 +2208,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
/* The following assert() is not a requirement, merely an observation:
** The OR-optimization doesn't work for the right hand table of
** a LEFT JOIN: */
- assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 );
+ assert( (pWInfo->wctrlFlags & (WHERE_OR_SUBCLAUSE|WHERE_RIGHT_JOIN))==0 );
}
/* Record the instruction used to terminate the loop. */
@@ -2534,6 +2550,14 @@ Bitmask sqlite3WhereCodeOneLoopStart(
sqlite3VdbeGoto(v, pLevel->addrBrk);
sqlite3VdbeResolveLabel(v, iLoopBody);
+ /* Set the P2 operand of the OP_Return opcode that will end the current
+ ** loop to point to this spot, which is the top of the next containing
+ ** loop. The byte-code formatter will use that P2 value as a hint to
+ ** indent everything in between the this point and the final OP_Return.
+ ** See tag-20220407a in vdbe.c and shell.c */
+ assert( pLevel->op==OP_Return );
+ pLevel->p2 = sqlite3VdbeCurrentAddr(v);
+
if( pWInfo->nLevel>1 ){ sqlite3StackFree(db, pOrTab); }
if( !untestedTerms ) disableTerm(pLevel, pTerm);
}else
@@ -2596,7 +2620,9 @@ Bitmask sqlite3WhereCodeOneLoopStart(
}
pE = pTerm->pExpr;
assert( pE!=0 );
- if( (pTabItem->fg.jointype&JT_LEFT) && !ExprHasProperty(pE,EP_FromJoin) ){
+ if( (pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ))
+ && !ExprHasProperty(pE,EP_FromJoin|EP_InnerJoin)
+ ){
continue;
}
@@ -2658,7 +2684,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue;
if( (pTerm->eOperator & WO_EQUIV)==0 ) continue;
if( pTerm->leftCursor!=iCur ) continue;
- if( pTabItem->fg.jointype & JT_LEFT ) continue;
+ if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ) ) continue;
pE = pTerm->pExpr;
#ifdef WHERETRACE_ENABLED /* 0x800 */
if( sqlite3WhereTrace & 0x800 ){
@@ -2689,6 +2715,47 @@ Bitmask sqlite3WhereCodeOneLoopStart(
pAlt->wtFlags |= TERM_CODED;
}
+ /* For a RIGHT OUTER JOIN, record the fact that the current row has
+ ** been matched at least once.
+ */
+ if( pLevel->pRJ ){
+ Table *pTab;
+ int nPk;
+ int r;
+ int jmp1 = 0;
+ WhereRightJoin *pRJ = pLevel->pRJ;
+
+ /* pTab is the right-hand table of the RIGHT JOIN. Generate code that
+ ** will record that the current row of that table has been matched at
+ ** least once. This is accomplished by storing the PK for the row in
+ ** both the iMatch index and the regBloom Bloom filter.
+ */
+ pTab = pWInfo->pTabList->a[pLevel->iFrom].pTab;
+ if( HasRowid(pTab) ){
+ r = sqlite3GetTempRange(pParse, 2);
+ sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
+ nPk = 1;
+ }else{
+ int iPk;
+ Index *pPk = sqlite3PrimaryKeyIndex(pTab);
+ nPk = pPk->nKeyCol;
+ r = sqlite3GetTempRange(pParse, nPk+1);
+ for(iPk=0; iPkaiColumn[iPk];
+ sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
+ }
+ }
+ jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, 0, r+1, nPk);
+ VdbeCoverage(v);
+ VdbeComment((v, "match against %s", pTab->zName));
+ sqlite3VdbeAddOp3(v, OP_MakeRecord, r+1, nPk, r);
+ sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pRJ->iMatch, r, r+1, nPk);
+ sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pRJ->regBloom, 0, r+1, nPk);
+ sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
+ sqlite3VdbeJumpHere(v, jmp1);
+ sqlite3ReleaseTempRange(pParse, r, nPk+1);
+ }
+
/* For a LEFT OUTER JOIN, generate code that will record the fact that
** at least one row of the right table has matched the left table.
*/
@@ -2704,12 +2771,27 @@ Bitmask sqlite3WhereCodeOneLoopStart(
assert( pWInfo->untestedTerms );
continue;
}
+ if( pTabItem->fg.jointype & JT_LTORJ ) continue;
assert( pTerm->pExpr );
sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
pTerm->wtFlags |= TERM_CODED;
}
}
+ if( pLevel->pRJ ){
+ /* Create a subroutine used to process all interior loops and code
+ ** of the RIGHT JOIN. During normal operation, the subroutine will
+ ** be in-line with the rest of the code. But at the end, a separate
+ ** loop will run that invokes this subroutine for unmatched rows
+ ** of pTab, with all tables to left begin set to NULL.
+ */
+ WhereRightJoin *pRJ = pLevel->pRJ;
+ sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pRJ->regReturn);
+ pRJ->addrSubrtn = sqlite3VdbeCurrentAddr(v);
+ assert( pParse->withinRJSubrtn < 255 );
+ pParse->withinRJSubrtn++;
+ }
+
#if WHERETRACE_ENABLED /* 0x20800 */
if( sqlite3WhereTrace & 0x20000 ){
sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n",
@@ -2723,3 +2805,89 @@ Bitmask sqlite3WhereCodeOneLoopStart(
#endif
return pLevel->notReady;
}
+
+/*
+** Generate the code for the loop that finds all non-matched terms
+** for a RIGHT JOIN.
+*/
+SQLITE_NOINLINE void sqlite3WhereRightJoinLoop(
+ WhereInfo *pWInfo,
+ int iLevel,
+ WhereLevel *pLevel
+){
+ Parse *pParse = pWInfo->pParse;
+ Vdbe *v = pParse->pVdbe;
+ WhereRightJoin *pRJ = pLevel->pRJ;
+ Expr *pSubWhere = 0;
+ WhereClause *pWC = &pWInfo->sWC;
+ WhereInfo *pSubWInfo;
+ WhereLoop *pLoop = pLevel->pWLoop;
+ SrcItem *pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
+ SrcList sFrom;
+ Bitmask mAll = 0;
+ int k;
+
+ ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
+ sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn,
+ pRJ->regReturn);
+ for(k=0; ka[k].pWLoop->maskSelf;
+ sqlite3VdbeAddOp1(v, OP_NullRow, pWInfo->a[k].iTabCur);
+ iIdxCur = pWInfo->a[k].iIdxCur;
+ if( iIdxCur ){
+ sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur);
+ }
+ }
+ if( (pTabItem->fg.jointype & JT_LTORJ)==0 ){
+ mAll |= pLoop->maskSelf;
+ for(k=0; knTerm; k++){
+ WhereTerm *pTerm = &pWC->a[k];
+ if( pTerm->wtFlags & TERM_VIRTUAL ) break;
+ if( pTerm->prereqAll & ~mAll ) continue;
+ if( ExprHasProperty(pTerm->pExpr, EP_FromJoin|EP_InnerJoin) ) continue;
+ pSubWhere = sqlite3ExprAnd(pParse, pSubWhere,
+ sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
+ }
+ }
+ sFrom.nSrc = 1;
+ sFrom.nAlloc = 1;
+ memcpy(&sFrom.a[0], pTabItem, sizeof(SrcItem));
+ sFrom.a[0].fg.jointype = 0;
+ assert( pParse->withinRJSubrtn < 100 );
+ pParse->withinRJSubrtn++;
+ pSubWInfo = sqlite3WhereBegin(pParse, &sFrom, pSubWhere, 0, 0, 0,
+ WHERE_RIGHT_JOIN, 0);
+ if( pSubWInfo ){
+ int iCur = pLevel->iTabCur;
+ int r = ++pParse->nMem;
+ int nPk;
+ int jmp;
+ int addrCont = sqlite3WhereContinueLabel(pSubWInfo);
+ Table *pTab = pTabItem->pTab;
+ if( HasRowid(pTab) ){
+ sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
+ nPk = 1;
+ }else{
+ int iPk;
+ Index *pPk = sqlite3PrimaryKeyIndex(pTab);
+ nPk = pPk->nKeyCol;
+ pParse->nMem += nPk - 1;
+ for(iPk=0; iPkaiColumn[iPk];
+ sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
+ }
+ }
+ jmp = sqlite3VdbeAddOp4Int(v, OP_Filter, pRJ->regBloom, 0, r, nPk);
+ VdbeCoverage(v);
+ sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, addrCont, r, nPk);
+ VdbeCoverage(v);
+ sqlite3VdbeJumpHere(v, jmp);
+ sqlite3VdbeAddOp2(v, OP_Gosub, pRJ->regReturn, pRJ->addrSubrtn);
+ sqlite3WhereEnd(pSubWInfo);
+ }
+ sqlite3ExprDelete(pParse->db, pSubWhere);
+ ExplainQueryPlanPop(pParse);
+ assert( pParse->withinRJSubrtn>0 );
+ pParse->withinRJSubrtn--;
+}
diff --git a/src/whereexpr.c b/src/whereexpr.c
index 19dd886de5..89c6a466ce 100644
--- a/src/whereexpr.c
+++ b/src/whereexpr.c
@@ -64,7 +64,7 @@ static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
if( pWC->nTerm>=pWC->nSlot ){
WhereTerm *pOld = pWC->a;
sqlite3 *db = pWC->pWInfo->pParse->db;
- pWC->a = sqlite3DbMallocRawNN(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
+ pWC->a = sqlite3WhereMalloc(pWC->pWInfo, sizeof(pWC->a[0])*pWC->nSlot*2 );
if( pWC->a==0 ){
if( wtFlags & TERM_DYNAMIC ){
sqlite3ExprDelete(db, p);
@@ -73,10 +73,7 @@ static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
return 0;
}
memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
- if( pOld!=pWC->aStatic ){
- sqlite3DbFree(db, pOld);
- }
- pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
+ pWC->nSlot = pWC->nSlot*2;
}
pTerm = &pWC->a[idx = pWC->nTerm++];
if( (wtFlags & TERM_VIRTUAL)==0 ) pWC->nBase = pWC->nTerm;
@@ -466,7 +463,7 @@ static int isAuxiliaryVtabOperator(
static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
if( pDerived ){
pDerived->flags |= pBase->flags & EP_FromJoin;
- pDerived->w.iRightJoinTable = pBase->w.iRightJoinTable;
+ pDerived->w.iJoin = pBase->w.iJoin;
}
}
@@ -951,7 +948,9 @@ static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){
int i;
for(i=0; inSrc; i++){
mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
- mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].pOn);
+ if( pSrc->a[i].fg.isUsing==0 ){
+ mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].u3.pOn);
+ }
if( pSrc->a[i].fg.isTabFunc ){
mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg);
}
@@ -1111,7 +1110,7 @@ static void exprAnalyze(
#endif
if( ExprHasProperty(pExpr, EP_FromJoin) ){
- Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iRightJoinTable);
+ Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iJoin);
prereqAll |= x;
extraRight = x-1; /* ON clause terms may not be used with an index
** on left table of a LEFT JOIN. Ticket #3015 */
@@ -1462,7 +1461,7 @@ static void exprAnalyze(
0, sqlite3ExprDup(db, pRight, 0));
if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
ExprSetProperty(pNewExpr, EP_FromJoin);
- pNewExpr->w.iRightJoinTable = pExpr->w.iRightJoinTable;
+ pNewExpr->w.iJoin = pExpr->w.iJoin;
}
idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
testcase( idxNew==0 );
@@ -1617,7 +1616,7 @@ void sqlite3WhereAddLimit(WhereClause *pWC, Select *p){
Expr *pExpr = pOrderBy->a[ii].pExpr;
if( pExpr->op!=TK_COLUMN ) return;
if( pExpr->iTable!=iCsr ) return;
- if( pOrderBy->a[ii].sortFlags & KEYINFO_ORDER_BIGNULL ) return;
+ if( pOrderBy->a[ii].fg.sortFlags & KEYINFO_ORDER_BIGNULL ) return;
}
}
@@ -1684,9 +1683,6 @@ void sqlite3WhereClauseClear(WhereClause *pWC){
a++;
}
}
- if( pWC->a!=pWC->aStatic ){
- sqlite3DbFree(db, pWC->a);
- }
}
@@ -1813,6 +1809,7 @@ void sqlite3WhereTabFuncArgs(
if( pArgs==0 ) return;
for(j=k=0; jnExpr; j++){
Expr *pRhs;
+ u32 joinType;
while( knCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
if( k>=pTab->nCol ){
sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d",
@@ -1829,9 +1826,12 @@ void sqlite3WhereTabFuncArgs(
pRhs = sqlite3PExpr(pParse, TK_UPLUS,
sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);
- if( pItem->fg.jointype & JT_LEFT ){
- sqlite3SetJoinExpr(pTerm, pItem->iCursor);
+ if( pItem->fg.jointype & (JT_LEFT|JT_LTORJ) ){
+ joinType = EP_FromJoin;
+ }else{
+ joinType = EP_InnerJoin;
}
+ sqlite3SetJoinExpr(pTerm, pItem->iCursor, joinType);
whereClauseInsert(pWC, pTerm, TERM_DYNAMIC);
}
}
diff --git a/src/window.c b/src/window.c
index d0ef81ae59..893668664f 100644
--- a/src/window.c
+++ b/src/window.c
@@ -916,7 +916,7 @@ static ExprList *exprListAppendList(
}
}
pList = sqlite3ExprListAppend(pParse, pList, pDup);
- if( pList ) pList->a[nInit+i].sortFlags = pAppend->a[i].sortFlags;
+ if( pList ) pList->a[nInit+i].fg.sortFlags = pAppend->a[i].fg.sortFlags;
}
}
return pList;
@@ -1729,7 +1729,7 @@ static void windowAggStep(
for(iEnd=sqlite3VdbeCurrentAddr(v); iOpopcode==OP_Column && pOp->p1==pWin->iEphCsr ){
+ if( pOp->opcode==OP_Column && pOp->p1==pMWin->iEphCsr ){
pOp->p1 = csr;
}
}
@@ -2117,7 +2117,7 @@ static void windowCodeRangeTest(
assert( op==OP_Ge || op==OP_Gt || op==OP_Le );
assert( pOrderBy && pOrderBy->nExpr==1 );
- if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_DESC ){
+ if( pOrderBy->a[0].fg.sortFlags & KEYINFO_ORDER_DESC ){
switch( op ){
case OP_Ge: op = OP_Le; break;
case OP_Gt: op = OP_Lt; break;
@@ -2150,7 +2150,7 @@ static void windowCodeRangeTest(
** Additionally, if either reg1 or reg2 are NULL but the jump to lbl is
** not taken, control jumps over the comparison operator coded below this
** block. */
- if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_BIGNULL ){
+ if( pOrderBy->a[0].fg.sortFlags & KEYINFO_ORDER_BIGNULL ){
/* This block runs if reg1 contains a NULL. */
int addr = sqlite3VdbeAddOp1(v, OP_NotNull, reg1); VdbeCoverage(v);
switch( op ){
diff --git a/test/affinity3.test b/test/affinity3.test
index ef1533a8f8..48942de72e 100644
--- a/test/affinity3.test
+++ b/test/affinity3.test
@@ -30,11 +30,24 @@ do_execsql_test affinity3-100 {
FROM customer c
LEFT JOIN apr i ON i.id=c.id;
+ CREATE VIEW v1rj AS
+ SELECT c.id, i.apr
+ FROM apr i
+ RIGHT JOIN customer c ON i.id=c.id;
+
CREATE VIEW v2 AS
SELECT c.id, v1.apr
FROM customer c
LEFT JOIN v1 ON v1.id=c.id;
+ CREATE VIEW v2rj AS
+ SELECT c.id, v1.apr
+ FROM v1 RIGHT JOIN customer c ON v1.id=c.id;
+
+ CREATE VIEW v2rjrj AS
+ SELECT c.id, v1rj.apr
+ FROM v1rj RIGHT JOIN customer c ON v1rj.id=c.id;
+
INSERT INTO customer (id) VALUES (1);
INSERT INTO apr (id, apr) VALUES (1, 12);
INSERT INTO customer (id) VALUES (2);
@@ -44,16 +57,35 @@ do_execsql_test affinity3-110 {
PRAGMA automatic_index=ON;
SELECT id, (apr / 100), typeof(apr) apr_type FROM v1;
} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-111 {
+ PRAGMA automatic_index=ON;
+ SELECT id, (apr / 100), typeof(apr) apr_type FROM v1rj;
+} {1 0.12 real 2 0.1201 real}
do_execsql_test affinity3-120 {
SELECT id, (apr / 100), typeof(apr) apr_type FROM v2;
} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-121 {
+ SELECT id, (apr / 100), typeof(apr) apr_type FROM v2rj;
+} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-122 {
+ SELECT id, (apr / 100), typeof(apr) apr_type FROM v2rjrj;
+} {1 0.12 real 2 0.1201 real}
do_execsql_test affinity3-130 {
PRAGMA automatic_index=OFF;
SELECT id, (apr / 100), typeof(apr) apr_type FROM v1;
} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-131 {
+ SELECT id, (apr / 100), typeof(apr) apr_type FROM v1rj;
+} {1 0.12 real 2 0.1201 real}
do_execsql_test affinity3-140 {
SELECT id, (apr / 100), typeof(apr) apr_type FROM v2;
} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-141 {
+ SELECT id, (apr / 100), typeof(apr) apr_type FROM v2rj;
+} {1 0.12 real 2 0.1201 real}
+do_execsql_test affinity3-142 {
+ SELECT id, (apr / 100), typeof(apr) apr_type FROM v2rjrj;
+} {1 0.12 real 2 0.1201 real}
# Ticket https://www.sqlite.org/src/info/7ffd1ca1d2ad4ecf (2017-01-16)
# Incorrect affinity when using automatic indexes
diff --git a/test/aggnested.test b/test/aggnested.test
index 35d5f1e3a6..1b8b608803 100644
--- a/test/aggnested.test
+++ b/test/aggnested.test
@@ -137,6 +137,17 @@ do_test aggnested-3.1 {
GROUP BY curr.id1);
}
} {1 1}
+do_test aggnested-3.1-rj {
+ db eval {
+ SELECT
+ (SELECT sum(value2==xyz) FROM t2)
+ FROM
+ (SELECT curr.value1 as xyz
+ FROM t1 AS other RIGHT JOIN t1 AS curr
+ GROUP BY curr.id1);
+ }
+} {1 1}
+
do_test aggnested-3.2 {
db eval {
DROP TABLE IF EXISTS t1;
diff --git a/test/altertab3.test b/test/altertab3.test
index 2b9aac3ef8..c786570451 100644
--- a/test/altertab3.test
+++ b/test/altertab3.test
@@ -686,4 +686,54 @@ do_execsql_test 28.2 {
UPDATE "t2" SET (c,d)=(a,b);
END}}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 29.1 {
+ CREATE TABLE t1(x, y);
+ CREATE TRIGGER Trigger1 DELETE ON t1
+ BEGIN
+ SELECT t1.*, t1.x FROM t1 ORDER BY t1.x;
+ END;
+}
+
+
+do_execsql_test 29.2 {
+ ALTER TABLE t1 RENAME x TO z;
+}
+
+do_execsql_test 29.3 {
+ ALTER TABLE t1 RENAME TO t2;
+}
+
+do_execsql_test 29.4 {
+ CREATE TRIGGER tr2 AFTER DELETE ON t2 BEGIN
+ SELECT z, y FROM (
+ SELECT t2.* FROM t2
+ );
+ END;
+}
+
+do_execsql_test 29.5 {
+ DELETE FROM t2
+}
+
+do_execsql_test 29.6 {
+ ALTER TABLE t2 RENAME TO t3;
+}
+
+do_execsql_test 29.7 {
+ SELECT sql FROM sqlite_schema WHERE type='trigger'
+} {
+ {CREATE TRIGGER Trigger1 DELETE ON "t3"
+ BEGIN
+ SELECT "t3".*, "t3".z FROM "t3" ORDER BY "t3".z;
+ END}
+ {CREATE TRIGGER tr2 AFTER DELETE ON "t3" BEGIN
+ SELECT z, y FROM (
+ SELECT "t3".* FROM "t3"
+ );
+ END}
+}
+
finish_test
diff --git a/test/analyze9.test b/test/analyze9.test
index a7f9b5deae..b2121fd07b 100644
--- a/test/analyze9.test
+++ b/test/analyze9.test
@@ -399,7 +399,7 @@ do_test 9.2 {
for {set i 0} {$i < 100} {incr i} {
execsql "INSERT INTO t1 VALUES('x', 'y', 'z', $i, [expr $i/2])"
}
- for {set i 0} {$i < 20} {incr i} {
+ for {set i 0} {$i < 21} {incr i} {
execsql "INSERT INTO t1 VALUES('x', 'y', 'z', 101, $i)"
}
for {set i 102} {$i < 200} {incr i} {
diff --git a/test/autoindex1.test b/test/autoindex1.test
index 6b437f1867..4b290c7961 100644
--- a/test/autoindex1.test
+++ b/test/autoindex1.test
@@ -283,7 +283,7 @@ do_eqp_test autoindex1-600a {
| `--CORRELATED SCALAR SUBQUERY xxxxxx
| `--SEARCH later USING COVERING INDEX sqlite_autoindex_flock_owner_1 (flock_no=? AND owner_change_date>? AND owner_change_date=300;
+} {2}
+
+# 2022-05-03 https://sqlite.org/forum/forumpost/2482b32700384a0f
+# Bloom-filter pull-down does not handle NOT NULL constraints correctly.
+#
+reset_db
+do_execsql_test 12.1 {
+ CREATE TABLE t1(a INT, b INT, c INT);
+ WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<100)
+ INSERT INTO t1(a,b,c) SELECT x, x*1000, x*1000000 FROM c;
+ CREATE TABLE t2(b INT, x INT);
+ INSERT INTO t2(b,x) SELECT b, a FROM t1 WHERE a%3==0;
+ CREATE INDEX t2b ON t2(b);
+ CREATE TABLE t3(c INT, y INT);
+ INSERT INTO t3(c,y) SELECT c, a FROM t1 WHERE a%4==0;
+ CREATE INDEX t3c ON t3(c);
+ INSERT INTO t1(a,b,c) VALUES(200, 200000, NULL);
+ ANALYZE;
+} {}
+do_execsql_test 12.2 {
+ SELECT * FROM t1 NATURAL JOIN t2 NATURAL JOIN t3 WHERE x>0 AND y>0
+ ORDER BY +a;
+} {
+ 12 12000 12000000 12 12
+ 24 24000 24000000 24 24
+ 36 36000 36000000 36 36
+ 48 48000 48000000 48 48
+ 60 60000 60000000 60 60
+ 72 72000 72000000 72 72
+ 84 84000 84000000 84 84
+ 96 96000 96000000 96 96
+}
+
+
+
finish_test
diff --git a/test/join7.test b/test/join7.test
new file mode 100644
index 0000000000..a665ba1a93
--- /dev/null
+++ b/test/join7.test
@@ -0,0 +1,289 @@
+# 2022-04-09
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests for RIGHT and FULL OUTER JOINs.
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+foreach {id schema} {
+ 1 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE INDEX t1a ON t1(a);
+ CREATE TABLE t2(c INT, d INT);
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE INDEX t2c ON t2(c);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 2 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE INDEX t1ab ON t1(a,b);
+ CREATE TABLE t2(c INT, d INT);
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE INDEX t2cd ON t2(c,d);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 3 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE INDEX t1a ON t1(a);
+ CREATE TABLE t2(c INT, d INT PRIMARY KEY) WITHOUT ROWID;
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE INDEX t2c ON t2(c);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 4 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE TABLE t2(c INTEGER PRIMARY KEY, d INT);
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 5 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE TABLE t2(c INT PRIMARY KEY, d INT) WITHOUT ROWID;
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 6 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE VIEW t2(c,d) AS VALUES(3,33),(4,44),(5,55);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 7 {
+ CREATE VIEW t1(a,b) AS VALUES(1,2),(1,3),(1,4);
+ CREATE TABLE t2(c INTEGER PRIMARY KEY, d INT);
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 8 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE TABLE t2(c INT, d INT);
+ INSERT INTO t2 VALUES(3,33),(4,44),(5,55);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ }
+ 9 {
+ CREATE TABLE t1(a INT, b INT);
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE TABLE t2a(c INTEGER PRIMARY KEY, i1 INT);
+ CREATE TABLE t2b(i1 INTEGER PRIMARY KEY, d INT);
+ CREATE VIEW t2(c,d) AS SELECT c, d FROM t2a NATURAL JOIN t2b;
+ INSERT INTO t2a VALUES(3,93),(4,94),(5,95),(6,96),(7,97);
+ INSERT INTO t2b VALUES(91,11),(92,22),(93,33),(94,44),(95,55);
+ CREATE TABLE dual(dummy TEXT);
+ INSERT INTO dual(dummy) VALUES('x');
+ }
+ 10 {
+ CREATE TABLE t1(a INT, b INT, PRIMARY KEY(a,b)) WITHOUT ROWID;
+ INSERT INTO t1 VALUES(1,2),(1,3),(1,4);
+ CREATE TABLE t2a(c INTEGER PRIMARY KEY, i1 INT);
+ CREATE TABLE t2b(i1 INTEGER PRIMARY KEY, d INT);
+ CREATE VIEW t2(c,d) AS SELECT c, d FROM t2a NATURAL JOIN t2b;
+ INSERT INTO t2a VALUES(3,93),(4,94),(5,95),(6,96),(7,97);
+ INSERT INTO t2b VALUES(91,11),(92,22),(93,33),(94,44),(95,55);
+ CREATE TABLE dual(dummy TEXT);
+ INSERT INTO dual(dummy) VALUES('x');
+ }
+} {
+ reset_db
+ db nullvalue NULL
+ do_execsql_test join7-$id.setup $schema {}
+
+ # Verified against PG-14 for case 1
+ do_execsql_test join7-$id.10 {
+ SELECT b, d FROM t1 FULL OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL 55
+ 2 NULL
+ 3 33
+ 4 44
+ }
+
+ # Verified against PG-14 for case 1
+ do_execsql_test join7-$id.20 {
+ SELECT a, c FROM t1 FULL OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL 5
+ 1 NULL
+ 1 3
+ 1 4
+ }
+
+ do_execsql_test join7-$id.30 {
+ SELECT * FROM t1 FULL OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.31 {
+ SELECT t1.*, t2.* FROM t2 FULL OUTER JOIN t1 ON b=c ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.40 {
+ SELECT * FROM t1 RIGHT OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.50 {
+ SELECT t1.*, t2.* FROM t2 LEFT OUTER JOIN t1 ON b=c ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.60 {
+ SELECT * FROM dual JOIN t1 ON true RIGHT OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL NULL NULL 5 55
+ x 1 3 3 33
+ x 1 4 4 44
+ }
+ do_execsql_test join7-$id.70 {
+ SELECT t1.*, t2.*
+ FROM t2 LEFT JOIN (dual JOIN t1 ON true) ON b=c ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.80 {
+ SELECT * FROM dual CROSS JOIN t1 RIGHT OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL NULL NULL 5 55
+ x 1 3 3 33
+ x 1 4 4 44
+ }
+ do_execsql_test join7-$id.81 {
+ SELECT dual.*, t1.*, t2.*
+ FROM t1 CROSS JOIN dual RIGHT OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ NULL NULL NULL 5 55
+ x 1 3 3 33
+ x 1 4 4 44
+ }
+ do_execsql_test join7-$id.90 {
+ SELECT * FROM t1 LEFT OUTER JOIN t2 ON b=c ORDER BY +b;
+ } {
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.100 {
+ SELECT * FROM t1 FULL OUTER JOIN t2 ON b=c AND a=1 ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+ do_execsql_test join7-$id.101 {
+ SELECT t1.*, t2.* FROM t2 FULL OUTER JOIN t1 ON b=c AND a=1 ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+
+ # Verified against PG-14 for case 1
+ do_execsql_test join7-$id.110 {
+ SELECT * FROM t1 FULL OUTER JOIN t2 ON b=c WHERE a=1 ORDER BY +b;
+ } {
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+
+ do_execsql_test join7-$id.111 {
+ SELECT t1.*, t2.* FROM t2 FULL OUTER JOIN t1 ON b=c WHERE a=1 ORDER BY +b;
+ } {
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+
+ # Verified against PG-14 for case 1
+ do_execsql_test join7-$id.115 {
+ SELECT * FROM t1 FULL OUTER JOIN t2 ON b=c
+ WHERE a=1 OR a IS NULL ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+
+ do_execsql_test join7-$id.116 {
+ SELECT t1.*, t2.* FROM t2 FULL OUTER JOIN t1 ON b=c
+ WHERE a=1 OR a IS NULL ORDER BY +b;
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 3 33
+ 1 4 4 44
+ }
+
+ # Verified against PG-14 for case 1:
+ do_execsql_test join7-$id.120 {
+ SELECT * FROM t1 FULL OUTER JOIN t2 ON b=c WHERE a IS NULL ORDER BY +d;
+ } {
+ NULL NULL 5 55
+ }
+
+ # Verified against PG-14 for case 1:
+ do_execsql_test join7-$id.130 {
+ SELECT * FROM t1 FULL OUTER JOIN t2 ON b=c AND d<=0 ORDER BY +b, +d;
+ } {
+ NULL NULL 3 33
+ NULL NULL 4 44
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 NULL NULL
+ 1 4 NULL NULL
+ }
+
+ # Verified against PG-14 for case 1:
+ do_execsql_test join7-$id.140 {
+ SELECT a, b, c, d
+ FROM t2 FULL OUTER JOIN t1 ON b=c AND d<=0 ORDER BY +b, +d;
+ } {
+ NULL NULL 3 33
+ NULL NULL 4 44
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ 1 3 NULL NULL
+ 1 4 NULL NULL
+ }
+
+ do_execsql_test join7-$id.141 {
+ SELECT a, b, c, d
+ FROM t2 FULL OUTER JOIN t1 ON b=c AND d<=0
+ ORDER BY +b, +d LIMIT 2 OFFSET 2
+ } {
+ NULL NULL 5 55
+ 1 2 NULL NULL
+ }
+}
+finish_test
diff --git a/test/join8.test b/test/join8.test
new file mode 100644
index 0000000000..3a3b06a1c4
--- /dev/null
+++ b/test/join8.test
@@ -0,0 +1,240 @@
+# 2022-04-12
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file implements tests for RIGHT and FULL OUTER JOINs.
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !vtab {
+ finish_test
+ return
+}
+
+db null NULL
+do_execsql_test join8-10 {
+ CREATE TABLE t1(a,b,c);
+ CREATE TABLE t2(x,y);
+ CREATE INDEX t2x ON t2(x);
+ SELECT avg(DISTINCT b) FROM (SELECT * FROM t2 LEFT RIGHT JOIN t1 ON c);
+} {NULL}
+
+# Pending optimization opportunity:
+# Row-value initialization subroutines must be called from with the
+# RIGHT JOIN body subroutine before the first use of any register containing
+# the results of that subroutine. This seems dodgy. Test case:
+#
+reset_db
+do_execsql_test join8-1000 {
+ CREATE TABLE t1(a INTEGER PRIMARY KEY AUTOINCREMENT,b,c,d,e,f,g,h,j,k,l,m,n,o,p,q,r,s);
+ CREATE INDEX t1x1 ON t1(g+h,j,k);
+ CREATE INDEX t1x2 ON t1(b);
+ INSERT INTO t1 DEFAULT VALUES;
+} {}
+do_catchsql_test join8-1010 {
+ SELECT a
+ FROM (
+ SELECT a
+ FROM (
+ SELECT a
+ FROM (
+ SELECT a FROM t1 NATURAL LEFT JOIN t1
+ WHERE (b, 2 ) IS ( SELECT 2 IN(2,2),2)
+ )
+ NATURAL LEFT FULL JOIN t1
+ WHERE ( rowid , 1 )<=(CASE 5 WHEN 619 THEN 841 ELSE 3374391096 END,0)
+ ORDER BY a ASC
+ )
+ NATURAL LEFT JOIN t1
+ WHERE (b, 2 ) IS ( SELECT 3 IN(3,3),3)
+ )
+ NATURAL LEFT FULL JOIN t1
+ WHERE ( rowid , 1 )<=(CASE 5 WHEN 619 THEN 841 ELSE 3374391096 END,0)
+ ORDER BY a ASC;
+} {0 1}
+
+# Pending issue #2: (now resolved)
+# Jump to addrHalt inside the RIGHT JOIN body subroutine bypasses the
+# OP_Return, resulting in a subroutine loop. Test case:
+#
+reset_db
+do_execsql_test join8-2000 {
+ CREATE TABLE t1(a int, b int, c int);
+ INSERT INTO t1 VALUES(1,2,3),(4,5,6);
+ CREATE TABLE t2(d int, e int);
+ INSERT INTO t2 VALUES(3,333),(4,444);
+ CREATE TABLE t3(f int, g int);
+ PRAGMA automatic_index=off;
+} {}
+do_catchsql_test join8-2010 {
+ SELECT * FROM t1 RIGHT JOIN t2 ON c=d JOIN t3 ON f=e;
+} {0 {}}
+
+# Demonstrate that nested FULL JOINs and USING clauses work
+#
+reset_db
+load_static_extension db series
+do_execsql_test join8-3000 {
+ CREATE TABLE t1(id INTEGER PRIMARY KEY, a INT);
+ CREATE TABLE t2(id INTEGER PRIMARY KEY, b INT);
+ CREATE TABLE t3(id INTEGER PRIMARY KEY, c INT);
+ CREATE TABLE t4(id INTEGER PRIMARY KEY, d INT);
+ CREATE TABLE t5(id INTEGER PRIMARY KEY, e INT);
+ CREATE TABLE t6(id INTEGER PRIMARY KEY, f INT);
+ CREATE TABLE t7(id INTEGER PRIMARY KEY, g INT);
+ CREATE TABLE t8(id INTEGER PRIMARY KEY, h INT);
+ INSERT INTO t1 SELECT value, 1 FROM generate_series(1,256) WHERE value & 1;
+ INSERT INTO t2 SELECT value, 1 FROM generate_series(1,256) WHERE value & 2;
+ INSERT INTO t3 SELECT value, 1 FROM generate_series(1,256) WHERE value & 4;
+ INSERT INTO t4 SELECT value, 1 FROM generate_series(1,256) WHERE value & 8;
+ INSERT INTO t5 SELECT value, 1 FROM generate_series(1,256) WHERE value & 16;
+ INSERT INTO t6 SELECT value, 1 FROM generate_series(1,256) WHERE value & 32;
+ INSERT INTO t7 SELECT value, 1 FROM generate_series(1,256) WHERE value & 64;
+ INSERT INTO t8 SELECT value, 1 FROM generate_series(1,256) WHERE value & 128;
+ CREATE TABLE t9 AS
+ SELECT id, h, g, f, e, d, c, b, a
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ NATURAL FULL JOIN t6
+ NATURAL FULL JOIN t7
+ NATURAL FULL JOIN t8;
+} {}
+do_execsql_test join8-3010 {
+ SELECT count(*) FROM t9;
+} {255}
+do_execsql_test join8-3020 {
+ SELECT id, count(*) FROM t9 GROUP BY id HAVING count(*)!=1;
+} {}
+do_execsql_test join8-3030 {
+ UPDATE t9 SET a=0 WHERE a IS NULL;
+ UPDATE t9 SET b=0 WHERE b IS NULL;
+ UPDATE t9 SET c=0 WHERE c IS NULL;
+ UPDATE t9 SET d=0 WHERE d IS NULL;
+ UPDATE t9 SET e=0 WHERE e IS NULL;
+ UPDATE t9 SET f=0 WHERE f IS NULL;
+ UPDATE t9 SET g=0 WHERE g IS NULL;
+ UPDATE t9 SET h=0 WHERE h IS NULL;
+ SELECT count(*) FROM t9 WHERE id=128*h+64*g+32*f+16*e+8*d+4*c+2*b+a;
+} {255}
+do_execsql_test join8-3040 {
+ SELECT * FROM t9 WHERE id<>128*h+64*g+32*f+16*e+8*d+4*c+2*b+a;
+} {}
+
+# 2022-04-21 dbsqlfuzz find
+#
+reset_db
+do_execsql_test join8-4000 {
+ CREATE TABLE t1(x INTEGER PRIMARY KEY, a, b);
+ INSERT INTO t1 VALUES(1,5555,4);
+ CREATE INDEX i1a ON t1(a);
+ CREATE INDEX i1b ON t1(b);
+ SELECT a FROM t1 NATURAL RIGHT JOIN t1 WHERE a=5555 OR (1,b)==(SELECT 2 IN (2,2),4);
+} {5555}
+
+# 2022-04-23 dbsqlfuzz c7ee5500e3abddec3557016de777713b80c790d3
+# Escape from the right-join body subroutine via the ORDER BY LIMIT optimization.
+#
+reset_db
+db null -
+do_catchsql_test join8-5000 {
+ CREATE TABLE t1(x);
+ INSERT INTO t1(x) VALUES(NULL),(NULL);
+ CREATE TABLE t2(c, d);
+ INSERT INTO t2(c,d) SELECT x, x FROM t1;
+ CREATE INDEX t2dc ON t2(d, c);
+ SELECT (SELECT c FROM sqlite_temp_schema FULL JOIN t2 ON d IN (1,2,3) ORDER BY d) AS x FROM t1;
+} {0 {- -}}
+
+# 2022-04-29 dbsqlfuzz 19f1102a70cf966ab249de56d944fc20dbebcfcf
+#
+reset_db
+do_execsql_test join8-6000 {
+ CREATE TABLE t1(a INTEGER PRIMARY KEY, b TEXT, c TEXT, d REAL);
+ INSERT INTO t1 VALUES(1,'A','aa',2.5);
+ SELECT * FROM t1 AS t2 NATURAL RIGHT JOIN t1 AS t3
+ WHERE (a,b) IN (SELECT rowid, b FROM t1);
+} {1 A aa 2.5}
+do_execsql_test join8-6010 {
+ DROP TABLE IF EXISTS t1;
+ CREATE TABLE t1(a INT PRIMARY KEY, b TEXT, c TEXT, d INT) WITHOUT ROWID;
+ INSERT INTO t1 VALUES(15,'xray','baker',42);
+ SELECT value, t1.* FROM json_each('7') NATURAL RIGHT JOIN t1
+ WHERE (a,b) IN (SELECT a, b FROM t1);
+} {7 15 xray baker 42}
+do_execsql_test join8-6020 {
+ DROP TABLE IF EXISTS t1;
+ CREATE TABLE t1(a INTEGER PRIMARY KEY,b);
+ INSERT INTO t1 VALUES(0,NULL),(1,2);
+ SELECT value, t1.* FROM json_each('17') NATURAL RIGHT JOIN t1
+ WHERE (a,b) IN (SELECT rowid, b FROM t1);
+} {17 1 2}
+
+# Bloom filter usage by RIGHT and FULL JOIN
+#
+reset_db
+do_execsql_test join8-7000 {
+CREATE TABLE t1(a INT, b INT, c INT, d INT);
+ WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x+1 FROM c WHERE x<10)
+ INSERT INTO t1(a,b,c,d) SELECT x, x+100, x+200, x+300 FROM c;
+ CREATE TABLE t2(b INT, x INT);
+ INSERT INTO t2(b,x) SELECT b, a FROM t1 WHERE a%2=0;
+ CREATE INDEX t2b ON t2(b);
+ CREATE TABLE t3(c INT, y INT);
+ INSERT INTO t3(c,y) SELECT c, a FROM t1 WHERE a%3=0;
+ CREATE INDEX t3c ON t3(c);
+ CREATE TABLE t4(d INT, z INT);
+ INSERT INTO t4(d,z) SELECT d, a FROM t1 WHERE a%5=0;
+ CREATE INDEX t4d ON t4(d);
+ INSERT INTO t1(a,b,c,d) VALUES
+ (96,NULL,296,396),
+ (97,197,NULL,397),
+ (98,198,298,NULL),
+ (99,NULL,NULL,NULL);
+ ANALYZE sqlite_schema;
+ INSERT INTO sqlite_stat1 VALUES('t4','t4d','20 1');
+ INSERT INTO sqlite_stat1 VALUES('t3','t3c','32 1');
+ INSERT INTO sqlite_stat1 VALUES('t2','t2b','48 1');
+ INSERT INTO sqlite_stat1 VALUES('t1',NULL,'100');
+ ANALYZE sqlite_schema;
+} {}
+db null -
+do_execsql_test join8-7010 {
+ WITH t0 AS MATERIALIZED (
+ SELECT t1.*, t2.*, t3.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ )
+ SELECT * FROM t0 FULL JOIN t4 ON t0.a=t4.d AND t4.z>0
+ ORDER BY coalesce(t0.a, t0.y+200, t4.d);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+}
+do_execsql_test join8-7020 {
+ EXPLAIN QUERY PLAN
+ WITH t0 AS MATERIALIZED (
+ SELECT t1.*, t2.*, t3.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ )
+ SELECT * FROM t0 FULL JOIN t4 ON t0.a=t4.d AND t4.z>0
+ ORDER BY coalesce(t0.a, t0.y+200, t4.d);
+} {/.*BLOOM FILTER ON t2.*BLOOM FILTER ON t3.*BLOOM FILTER ON t4.*/}
+
+finish_test
diff --git a/test/join9.test b/test/join9.test
new file mode 100644
index 0000000000..e547d4ce70
--- /dev/null
+++ b/test/join9.test
@@ -0,0 +1,565 @@
+# 2022-04-16
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests for RIGHT and FULL OUTER JOINs.
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+foreach {id schema} {
+ 1 {
+ CREATE TABLE t3(id INTEGER PRIMARY KEY, w TEXT);
+ CREATE TABLE t4(id INTEGER PRIMARY KEY, x TEXT);
+ CREATE TABLE t5(id INTEGER PRIMARY KEY, y TEXT);
+ CREATE TABLE t6(id INTEGER PRIMARY KEY, z INT);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ INSERT INTO t3(id,w) VALUES(2,'two'),(3,'three'),(6,'six'),(7,'seven');
+ INSERT INTO t4(id,x) VALUES(2,'alice'),(4,'bob'),(6,'cindy'),(8,'dave');
+ INSERT INTO t5(id,y) VALUES(1,'red'),(2,'orange'),(3,'yellow'),(4,'green'),
+ (5,'blue');
+ INSERT INTO t6(id,z) VALUES(3,333),(4,444),(5,555),(0,1000),(9,999);
+ }
+ 2 {
+ CREATE TABLE t3(id INT PRIMARY KEY, w TEXT) WITHOUT ROWID;
+ CREATE TABLE t4(id INT PRIMARY KEY, x TEXT) WITHOUT ROWID;
+ CREATE TABLE t5(id INT PRIMARY KEY, y TEXT) WITHOUT ROWID;
+ CREATE TABLE t6(id INT PRIMARY KEY, z INT) WITHOUT ROWID;
+ CREATE TABLE dual(dummy TEXT);
+ INSERT INTO dual(dummy) VALUES('x');
+ INSERT INTO t3(id,w) VALUES(2,'two'),(3,'three'),(6,'six'),(7,'seven');
+ INSERT INTO t4(id,x) VALUES(2,'alice'),(4,'bob'),(6,'cindy'),(8,'dave');
+ INSERT INTO t5(id,y) VALUES(1,'red'),(2,'orange'),(3,'yellow'),(4,'green'),
+ (5,'blue');
+ INSERT INTO t6(id,z) VALUES(3,333),(4,444),(5,555),(0,1000),(9,999);
+ }
+ 3 {
+ CREATE TABLE t3x(id INTEGER PRIMARY KEY, w TEXT);
+ CREATE TABLE t4x(id INTEGER PRIMARY KEY, x TEXT);
+ CREATE TABLE t5x(id INTEGER PRIMARY KEY, y TEXT);
+ CREATE TABLE t6x(id INTEGER PRIMARY KEY, z INT);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ INSERT INTO t3x(id,w) VALUES(2,'two'),(3,'three'),(6,'six'),(7,'seven');
+ INSERT INTO t4x(id,x) VALUES(2,'alice'),(4,'bob'),(6,'cindy'),(8,'dave');
+ INSERT INTO t5x(id,y) VALUES(1,'red'),(2,'orange'),(3,'yellow'),(4,'green'),
+ (5,'blue');
+ INSERT INTO t6x(id,z) VALUES(3,333),(4,444),(5,555),(0,1000),(9,999);
+ CREATE VIEW t3 AS SELECT * FROM t3x LIMIT 1000;
+ CREATE VIEW t4 AS SELECT * FROM t4x LIMIT 1000;
+ CREATE VIEW t5 AS SELECT * FROM t5x LIMIT 1000;
+ CREATE VIEW t6 AS SELECT * FROM t6x LIMIT 1000;
+ }
+ 4 {
+ CREATE TABLE t3a(id INTEGER PRIMARY KEY, w TEXT);
+ CREATE TABLE t3b(id INTEGER PRIMARY KEY, w TEXT);
+ CREATE TABLE t4a(id INTEGER PRIMARY KEY, x TEXT);
+ CREATE TABLE t4b(id INTEGER PRIMARY KEY, x TEXT);
+ CREATE TABLE t5a(id INTEGER PRIMARY KEY, y TEXT);
+ CREATE TABLE t5b(id INTEGER PRIMARY KEY, y TEXT);
+ CREATE TABLE t6a(id INTEGER PRIMARY KEY, z INT);
+ CREATE TABLE t6b(id INTEGER PRIMARY KEY, z INT);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ INSERT INTO t3a(id,w) VALUES(2,'two'),(3,'three');
+ INSERT INTO t3b(id,w) VALUES(6,'six'),(7,'seven');
+ INSERT INTO t4a(id,x) VALUES(2,'alice'),(4,'bob');
+ INSERT INTO t4b(id,x) VALUES(6,'cindy'),(8,'dave');
+ INSERT INTO t5a(id,y) VALUES(1,'red'),(2,'orange'),(3,'yellow');
+ INSERT INTO t5b(id,y) VALUES(4,'green'),(5,'blue');
+ INSERT INTO t6a(id,z) VALUES(3,333),(4,444);
+ INSERT INTO t6b(id,z) VALUES(5,555),(0,1000),(9,999);
+ CREATE VIEW t3 AS SELECT * FROM t3a UNION ALL SELECT * FROM t3b;
+ CREATE VIEW t4 AS SELECT * FROM t4a UNION ALL SELECT * FROM t4b;
+ CREATE VIEW t5 AS SELECT * FROM t5a UNION ALL SELECT * FROM t5b;
+ CREATE VIEW t6 AS SELECT * FROM t6a UNION ALL SELECT * FROM t6b;
+ }
+ 5 {
+ CREATE TABLE t3a(id INTEGER PRIMARY KEY, w TEXT) WITHOUT ROWID;
+ CREATE TABLE t3b(id INTEGER PRIMARY KEY, w TEXT);
+ CREATE TABLE t4a(id INTEGER PRIMARY KEY, x TEXT) WITHOUT ROWID;
+ CREATE TABLE t4b(id INTEGER PRIMARY KEY, x TEXT) WITHOUT ROWID;
+ CREATE TABLE t5a(id INTEGER PRIMARY KEY, y TEXT);
+ CREATE TABLE t5b(id INTEGER PRIMARY KEY, y TEXT) WITHOUT ROWID;
+ CREATE TABLE t6a(id INTEGER PRIMARY KEY, z INT);
+ CREATE TABLE t6b(id INTEGER PRIMARY KEY, z INT);
+ CREATE VIEW dual(dummy) AS VALUES('x');
+ INSERT INTO t3a(id,w) VALUES(2,'two'),(3,'three');
+ INSERT INTO t3b(id,w) VALUES(6,'six'),(7,'seven');
+ INSERT INTO t4a(id,x) VALUES(2,'alice'),(4,'bob');
+ INSERT INTO t4b(id,x) VALUES(6,'cindy'),(8,'dave');
+ INSERT INTO t5a(id,y) VALUES(1,'red'),(2,'orange'),(3,'yellow');
+ INSERT INTO t5b(id,y) VALUES(4,'green'),(5,'blue');
+ INSERT INTO t6a(id,z) VALUES(3,333),(4,444);
+ INSERT INTO t6b(id,z) VALUES(5,555),(0,1000),(9,999);
+ CREATE VIEW t3 AS SELECT * FROM t3a UNION ALL SELECT * FROM t3b;
+ CREATE VIEW t4 AS SELECT * FROM t4a UNION ALL SELECT * FROM t4b LIMIT 50;
+ CREATE VIEW t5 AS SELECT * FROM t5a UNION ALL SELECT * FROM t5b LIMIT 100;
+ CREATE VIEW t6 AS SELECT * FROM t6a UNION ALL SELECT * FROM t6b;
+ }
+} {
+ reset_db
+ db nullvalue -
+ do_execsql_test join9-$id.setup $schema {}
+
+ # Verifid by PG-14 for case 1
+ do_execsql_test join9-$id.100 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 NATURAL LEFT JOIN t5 NATURAL LEFT JOIN t6
+ ORDER BY 1;
+ } {
+ 2 alice orange - 2 2 -
+ 4 bob green 444 4 4 4
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ }
+
+ do_execsql_test join9-$id.101 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 NATURAL LEFT JOIN t5 NATURAL LEFT JOIN t6
+ ORDER BY id;
+ } {
+ 2 alice orange - 2 2 -
+ 4 bob green 444 4 4 4
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ }
+ do_execsql_test join9-$id.102 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 LEFT JOIN t5 USING(id) LEFT JOIN t6 USING(id)
+ ORDER BY id;
+ } {
+ 2 alice orange - 2 2 -
+ 4 bob green 444 4 4 4
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ }
+
+ # Verifid by PG-14 using case 1
+ do_execsql_test join9-$id.200 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t5 NATURAL RIGHT JOIN t4 NATURAL LEFT JOIN t6
+ ORDER BY 1;
+ } {
+ 2 alice orange - 2 2 -
+ 4 bob green 444 4 4 4
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ }
+
+ do_execsql_test join9-$id.201 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t5 NATURAL RIGHT JOIN t4 NATURAL LEFT JOIN t6
+ ORDER BY id;
+ } {
+ 2 alice orange - 2 2 -
+ 4 bob green 444 4 4 4
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ }
+
+ # Verified by PG-14 using case 1
+ do_execsql_test join9-$id.300 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 NATURAL RIGHT JOIN t5 NATURAL RIGHT JOIN t6
+ ORDER BY 1;
+ } {
+ 0 - - 1000 - - 0
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 9 - - 999 - - 9
+ }
+
+ do_execsql_test join9-$id.301 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 NATURAL RIGHT JOIN t5 NATURAL RIGHT JOIN t6
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 9 - - 999 - - 9
+ }
+
+ # Verified by PG-14 for case 1
+ do_execsql_test join9-$id.400 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 NATURAL FULL JOIN t5 NATURAL FULL JOIN t6
+ ORDER BY 1;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+
+ do_execsql_test join9-$id.401 {
+ SELECT *, t4.id, t5.id, t6.id
+ FROM t4 NATURAL FULL JOIN t5 NATURAL FULL JOIN t6
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+ do_execsql_test join9-$id.402 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t4 NATURAL FULL JOIN t6 NATURAL FULL JOIN t5
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+ do_execsql_test join9-$id.403 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t5 NATURAL FULL JOIN t4 NATURAL FULL JOIN t6
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+ do_execsql_test join9-$id.404 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t5 NATURAL FULL JOIN t6 NATURAL FULL JOIN t4
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+ do_execsql_test join9-$id.405 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t6 NATURAL FULL JOIN t4 NATURAL FULL JOIN t5
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+ do_execsql_test join9-$id.406 {
+ SELECT id, x, y, z, t4.id, t5.id, t6.id
+ FROM t6 NATURAL FULL JOIN t5 NATURAL FULL JOIN t4
+ ORDER BY id;
+ } {
+ 0 - - 1000 - - 0
+ 1 - red - - 1 -
+ 2 alice orange - 2 2 -
+ 3 - yellow 333 - 3 3
+ 4 bob green 444 4 4 4
+ 5 - blue 555 - 5 5
+ 6 cindy - - 6 - -
+ 8 dave - - 8 - -
+ 9 - - 999 - - 9
+ }
+
+ # Verified by PG-14 using case 1
+ do_execsql_test join9-$id.500 {
+ SELECT id, w, x, y, z
+ FROM t3 FULL JOIN t4 USING(id)
+ NATURAL FULL JOIN t5
+ FULL JOIN t6 USING(id)
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 4 - bob green 444
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+
+ # Verified by PG-14 using case 1
+ do_execsql_test join9-$id.600 {
+ SELECT id, w, x, y, z
+ FROM t3 JOIN dual AS d1 ON true
+ FULL JOIN t4 USING(id)
+ JOIN dual AS d2 ON true
+ NATURAL FULL JOIN t5
+ JOIN dual AS d3 ON true
+ FULL JOIN t6 USING(id)
+ CROSS JOIN dual AS d4
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 4 - bob green 444
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+
+ # Verified by PG-14 using case 1
+ do_execsql_test join9-$id.700 {
+ SELECT id, w, x, y, z
+ FROM t3 JOIN dual AS d1 ON true
+ FULL JOIN t4 USING(id)
+ JOIN dual AS d2 ON true
+ NATURAL FULL JOIN t5
+ JOIN dual AS d3 ON true
+ FULL JOIN t6 USING(id)
+ CROSS JOIN dual AS d4
+ WHERE x<>'bob' OR x IS NULL
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+
+ # Verified by PG-14 using case 1
+ do_execsql_test join9-$id.800 {
+ WITH t7(id,a) AS MATERIALIZED (SELECT * FROM t4 WHERE false)
+ SELECT *
+ FROM t7
+ JOIN t7 AS t7b USING(id)
+ FULL JOIN t3 USING(id);
+ } {
+ 2 - - two
+ 3 - - three
+ 6 - - six
+ 7 - - seven
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.900 {
+ SELECT *
+ FROM (t3 NATURAL FULL JOIN t4)
+ NATURAL FULL JOIN
+ (t5 NATURAL FULL JOIN t6)
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 4 - bob green 444
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+ do_execsql_test join9-$id.910 {
+ SELECT *
+ FROM t3 NATURAL FULL JOIN
+ (t4 NATURAL FULL JOIN
+ (t5 NATURAL FULL JOIN t6))
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 4 - bob green 444
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+ do_execsql_test join9-$id.920 {
+ SELECT *
+ FROM t3 FULL JOIN (
+ t4 FULL JOIN (
+ t5 FULL JOIN t6 USING (id)
+ ) USING(id)
+ ) USING(id)
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 4 - bob green 444
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+ do_execsql_test join9-$id.920 {
+ SELECT *
+ FROM t3 FULL JOIN (
+ t4 FULL JOIN (
+ t5 FULL JOIN t6 USING (id)
+ ) USING(id)
+ ) USING(id)
+ ORDER BY 1;
+ } {
+ 0 - - - 1000
+ 1 - - red -
+ 2 two alice orange -
+ 3 three - yellow 333
+ 4 - bob green 444
+ 5 - - blue 555
+ 6 six cindy - -
+ 7 seven - - -
+ 8 - dave - -
+ 9 - - - 999
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.930 {
+ SELECT *
+ FROM t3 FULL JOIN (
+ t4 FULL JOIN (
+ t5 FULL JOIN t6 USING(id)
+ ) USING(id)
+ ) AS j1 ON j1.id=t3.id
+ ORDER BY coalesce(t3.id,j1.id);
+ } {
+ - - 0 - - 1000
+ - - 1 - red -
+ 2 two 2 alice orange -
+ 3 three 3 - yellow 333
+ - - 4 bob green 444
+ - - 5 - blue 555
+ 6 six 6 cindy - -
+ 7 seven - - - -
+ - - 8 dave - -
+ - - 9 - - 999
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.940 {
+ SELECT *
+ FROM t3 FULL JOIN (
+ t4 RIGHT JOIN (
+ t5 FULL JOIN t6 USING(id)
+ ) USING(id)
+ ) AS j1 ON j1.id=t3.id
+ ORDER BY coalesce(t3.id,j1.id);
+ } {
+ - - 0 - - 1000
+ - - 1 - red -
+ 2 two 2 alice orange -
+ 3 three 3 - yellow 333
+ - - 4 bob green 444
+ - - 5 - blue 555
+ 6 six - - - -
+ 7 seven - - - -
+ - - 9 - - 999
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.950 {
+ SELECT *
+ FROM t3 FULL JOIN (
+ t4 LEFT JOIN (
+ t5 FULL JOIN t6 USING(id)
+ ) USING(id)
+ ) AS j1 ON j1.id=t3.id
+ ORDER BY coalesce(t3.id,j1.id);
+ } {
+ 2 two 2 alice orange -
+ 3 three - - - -
+ - - 4 bob green 444
+ 6 six 6 cindy - -
+ 7 seven - - - -
+ - - 8 dave - -
+ }
+
+ # Restriction (27) in the query flattener
+ # Verified by PG-14
+ do_execsql_test join9-$id.1000 {
+ WITH t56(id,y,z) AS (SELECT * FROM t5 FULL JOIN t6 USING(id) LIMIT 50)
+ SELECT id,x,y,z FROM t4 JOIN t56 USING(id)
+ ORDER BY 1;
+ } {
+ 2 alice orange -
+ 4 bob green 444
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.1010 {
+ SELECT id,x,y,z
+ FROM t4 INNER JOIN (t5 FULL JOIN t6 USING(id)) USING(id)
+ ORDER BY 1;
+ } {
+ 2 alice orange -
+ 4 bob green 444
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.1020 {
+ SELECT id,x,y,z
+ FROM t4 FULL JOIN t5 USING(id) INNER JOIN t6 USING(id)
+ ORDER BY 1;
+ } {
+ 3 - yellow 333
+ 4 bob green 444
+ 5 - blue 555
+ }
+
+ # Verified by PG-14
+ do_execsql_test join9-$id.1030 {
+ WITH t45(id,x,y) AS (SELECT * FROM t4 FULL JOIN t5 USING(id) LIMIT 50)
+ SELECT id,x,y,z FROM t45 JOIN t6 USING(id)
+ ORDER BY 1;
+ } {
+ 3 - yellow 333
+ 4 bob green 444
+ 5 - blue 555
+ }
+
+}
+finish_test
diff --git a/test/joinA.test b/test/joinA.test
new file mode 100644
index 0000000000..d6bb678c54
--- /dev/null
+++ b/test/joinA.test
@@ -0,0 +1,214 @@
+# 2022-04-18
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.
+#
+# This file implements tests for RIGHT and FULL OUTER JOINs.
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+foreach {id schema} {
+ 1 {
+ CREATE TABLE t1(a INT, b INT, c INT, d INT);
+ CREATE TABLE t2(c INT, d INT, e INT, f INT);
+ CREATE TABLE t3(a INT, b INT, e INT, f INT);
+ CREATE TABLE t4(a INT, c INT, d INT, f INT);
+ INSERT INTO t1 VALUES(11,21,31,41),(12,22,32,42),(15,25,35,45),(18,28,38,48);
+ INSERT INTO t2 VALUES(12,22,32,42),(13,23,33,43),(15,25,35,45),(17,27,37,47);
+ INSERT INTO t3 VALUES(14,24,34,44),(15,25,35,45),(16,26,36,46);
+ INSERT INTO t4 VALUES(11,21,31,41),(13,23,33,43),(16,26,36,46),(19,29,39,49);
+ }
+ 2 {
+ CREATE TABLE t1(a INTEGER PRIMARY KEY, b INT, c INT, d INT);
+ CREATE TABLE t2(c INT, d INTEGER PRIMARY KEY, e INT, f INT);
+ CREATE TABLE t3(a INT, b INT, e INTEGER PRIMARY KEY, f INT);
+ CREATE TABLE t4(a INT, c INT, d INT, f INT PRIMARY KEY) WITHOUT ROWID;
+ INSERT INTO t1 VALUES(11,21,31,41),(12,22,32,42),(15,25,35,45),(18,28,38,48);
+ INSERT INTO t2 VALUES(12,22,32,42),(13,23,33,43),(15,25,35,45),(17,27,37,47);
+ INSERT INTO t3 VALUES(14,24,34,44),(15,25,35,45),(16,26,36,46);
+ INSERT INTO t4 VALUES(11,21,31,41),(13,23,33,43),(16,26,36,46),(19,29,39,49);
+ }
+ 3 {
+ CREATE TABLE t1a(a INT, b INT, c INT, d INT);
+ CREATE TABLE t2a(c INT, d INT, e INT, f INT);
+ CREATE TABLE t3a(a INT, b INT, e INT, f INT);
+ CREATE TABLE t4a(a INT, c INT, d INT, f INT);
+ INSERT INTO t1a VALUES(11,21,31,41),(12,22,32,42);
+ INSERT INTO t2a VALUES(12,22,32,42),(13,23,33,43);
+ INSERT INTO t3a VALUES(14,24,34,44),(15,25,35,45);
+ INSERT INTO t4a VALUES(11,21,31,41),(13,23,33,43);
+ CREATE TABLE t1b(a INT, b INT, c INT, d INT);
+ CREATE TABLE t2b(c INT, d INT, e INT, f INT);
+ CREATE TABLE t3b(a INT, b INT, e INT, f INT);
+ CREATE TABLE t4b(a INT, c INT, d INT, f INT);
+ INSERT INTO t1b VALUES(15,25,35,45),(18,28,38,48);
+ INSERT INTO t2b VALUES(15,25,35,45),(17,27,37,47);
+ INSERT INTO t3b VALUES(15,25,35,45),(16,26,36,46);
+ INSERT INTO t4b VALUES(16,26,36,46),(19,29,39,49);
+ CREATE VIEW t1 AS SELECT * FROM t1a UNION SELECT * FROM t1b;
+ CREATE VIEW t2 AS SELECT * FROM t2a UNION SELECT * FROM t2b;
+ CREATE VIEW t3 AS SELECT * FROM t3a UNION SELECT * FROM t3b;
+ CREATE VIEW t4 AS SELECT * FROM t4a UNION SELECT * FROM t4b;
+ }
+} {
+ reset_db
+ db nullvalue -
+ do_execsql_test joinA-$id.setup $schema {}
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.100 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ INNER JOIN t2 USING(c,d)
+ INNER JOIN t3 USING(a,b,f)
+ INNER JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {}
+
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.110 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ LEFT JOIN t2 USING(c,d)
+ LEFT JOIN t3 USING(a,b,f)
+ LEFT JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ 11 21 31 41 - - -
+ 12 22 32 42 - - -
+ 15 25 35 45 - - -
+ 18 28 38 48 - - -
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.120 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ LEFT JOIN t2 USING(c,d)
+ RIGHT JOIN t3 USING(a,b,f)
+ LEFT JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ 14 24 - - - 44 34
+ 15 25 - - - 45 35
+ 16 26 - - - 46 36
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.130 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ RIGHT JOIN t2 USING(c,d)
+ LEFT JOIN t3 USING(a,b,f)
+ RIGHT JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ 11 - 21 31 - 41 -
+ 13 - 23 33 - 43 -
+ 16 - 26 36 - 46 -
+ 19 - 29 39 - 49 -
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.140 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ FULL JOIN t2 USING(c,d)
+ LEFT JOIN t3 USING(a,b,f)
+ RIGHT JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ 11 - 21 31 - 41 -
+ 13 - 23 33 - 43 -
+ 16 - 26 36 - 46 -
+ 19 - 29 39 - 49 -
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.150 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ RIGHT JOIN t2 USING(c,d)
+ FULL JOIN t3 USING(a,b,f)
+ RIGHT JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ 11 - 21 31 - 41 -
+ 13 - 23 33 - 43 -
+ 16 - 26 36 - 46 -
+ 19 - 29 39 - 49 -
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.160 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ RIGHT JOIN t2 USING(c,d)
+ LEFT JOIN t3 USING(a,b,f)
+ FULL JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ - - 12 22 32 42 -
+ - - 13 23 33 43 -
+ - - 15 25 35 45 -
+ - - 17 27 37 47 -
+ 11 - 21 31 - 41 -
+ 13 - 23 33 - 43 -
+ 16 - 26 36 - 46 -
+ 19 - 29 39 - 49 -
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.170 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ LEFT JOIN t2 USING(c,d)
+ RIGHT JOIN t3 USING(a,b,f)
+ FULL JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ 11 - 21 31 - 41 -
+ 13 - 23 33 - 43 -
+ 14 24 - - - 44 34
+ 15 25 - - - 45 35
+ 16 26 - - - 46 36
+ 16 - 26 36 - 46 -
+ 19 - 29 39 - 49 -
+ }
+
+ # Verified by PG-14
+ do_execsql_test joinA-$id.200 {
+ SELECT a,b,c,d,t2.e,f,t3.e
+ FROM t1
+ FULL JOIN t2 USING(c,d)
+ FULL JOIN t3 USING(a,b,f)
+ FULL JOIN t4 USING(a,c,d,f)
+ ORDER BY 1 nulls first, 3 nulls first;
+ } {
+ - - 12 22 32 42 -
+ - - 13 23 33 43 -
+ - - 15 25 35 45 -
+ - - 17 27 37 47 -
+ 11 - 21 31 - 41 -
+ 11 21 31 41 - - -
+ 12 22 32 42 - - -
+ 13 - 23 33 - 43 -
+ 14 24 - - - 44 34
+ 15 25 - - - 45 35
+ 15 25 35 45 - - -
+ 16 26 - - - 46 36
+ 16 - 26 36 - 46 -
+ 18 28 38 48 - - -
+ 19 - 29 39 - 49 -
+ }
+}
+finish_test
diff --git a/test/joinB.test b/test/joinB.test
new file mode 100644
index 0000000000..baaeae677e
--- /dev/null
+++ b/test/joinB.test
@@ -0,0 +1,7252 @@
+set testdir [file dirname $argv0]
+# 2022-04-19
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file implements tests for JOINs.
+#
+# The test case output is all generated by PostgreSQL 14. This test module
+# was created as follows:
+#
+# 1. Run a TCL script (included at the bottom of this file) that
+# generates an input script for "psql" that will run man
+# diverse tests on joins.
+#
+# 2. Run the script from step (1) through psql and collect the
+# output.
+#
+# 3. Make a few minor global search-and-replace operations to convert
+# the psql output into a form suitable for this test module.
+#
+# 4. Add this header, and the script content at the footer.
+#
+source $testdir/tester.tcl
+db nullvalue -
+db eval {
+ DROP TABLE IF EXISTS t1;
+ DROP TABLE IF EXISTS t2;
+ DROP TABLE IF EXISTS t3;
+ DROP TABLE IF EXISTS t4;
+ DROP TABLE IF EXISTS t5;
+ CREATE TABLE t1(a INT, b INT, c INT);
+ CREATE TABLE t2(a INT, b INT, d INT);
+ CREATE TABLE t3(a INT, b INT, e INT);
+ CREATE TABLE t4(a INT, b INT, f INT);
+ CREATE TABLE t5(a INT, b INT, g INT);
+ INSERT INTO t1 VALUES(11,21,31),(12,22,32),(15,25,35),(17,27,37);
+ INSERT INTO t2 VALUES(12,22,32),(13,23,33),(15,25,35),(18,28,38),
+ (NULL,NULL,36);
+ INSERT INTO t4 VALUES(11,21,31),(13,23,33),(15,25,35),(19,29,39);
+ INSERT INTO t3 SELECT * FROM t1 UNION SELECT * FROM t2 UNION SELECT * FROM t4;
+ INSERT INTO t5 SELECT * FROM t3 WHERE a>=15;
+}
+do_execsql_test joinB-1 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-2 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-3 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-4 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-5 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-6 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-7 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-8 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-9 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-10 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-11 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-12 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-13 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-14 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-15 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-16 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-17 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-18 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-19 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-20 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-21 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-22 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-23 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-24 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-25 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-26 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-27 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-28 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-29 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-30 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-31 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-32 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-33 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-34 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-35 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-36 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-37 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-38 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-39 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-40 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-41 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-42 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-43 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-44 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-45 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-46 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-47 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-48 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-49 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-50 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-51 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-52 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-53 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-54 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-55 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-56 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-57 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-58 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-59 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-60 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-61 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-62 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-63 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-64 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-65 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-66 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-67 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-68 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-69 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-70 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-71 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-72 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-73 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-74 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-75 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-76 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-77 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-78 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-79 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-80 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-81 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-82 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-83 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-84 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-85 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-86 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-87 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-88 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-89 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-90 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-91 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-92 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-93 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-94 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-95 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-96 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-97 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-98 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-99 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-100 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-101 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-102 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-103 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-104 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-105 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-106 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-107 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-108 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-109 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-110 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-111 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-112 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-113 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-114 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-115 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-116 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-117 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-118 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-119 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-120 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-121 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-122 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-123 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-124 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ INNER JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-125 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-126 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ INNER JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-127 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ INNER JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-128 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL INNER JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-129 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-130 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-131 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-132 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-133 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-134 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-135 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-136 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-137 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+}
+do_execsql_test joinB-138 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+}
+do_execsql_test joinB-139 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+}
+do_execsql_test joinB-140 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+}
+do_execsql_test joinB-141 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-142 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-143 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-144 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-145 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-146 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-147 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-148 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-149 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-150 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-151 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-152 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-153 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 19 - - - 19 19
+}
+do_execsql_test joinB-154 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 19 - - - 39 39
+}
+do_execsql_test joinB-155 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 19 - - - 19 19
+}
+do_execsql_test joinB-156 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+}
+do_execsql_test joinB-157 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-158 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-159 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-160 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-161 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-162 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-163 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-164 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-165 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-166 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-167 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-168 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-169 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+}
+do_execsql_test joinB-170 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+}
+do_execsql_test joinB-171 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+}
+do_execsql_test joinB-172 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+}
+do_execsql_test joinB-173 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-174 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-175 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-176 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-177 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-178 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-179 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-180 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-181 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-182 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-183 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-184 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-185 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 19 - - - 19 19
+}
+do_execsql_test joinB-186 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 19 - - - 39 39
+}
+do_execsql_test joinB-187 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 19 - - - 19 19
+}
+do_execsql_test joinB-188 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+}
+do_execsql_test joinB-189 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-190 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-191 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - - 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-192 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-193 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-194 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-195 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-196 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-197 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-198 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-199 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-200 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-201 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-202 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-203 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-204 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-205 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-206 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-207 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-208 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-209 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-210 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-211 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-212 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-213 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-214 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-215 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-216 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-217 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-218 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-219 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-220 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-221 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-222 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-223 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-224 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-225 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-226 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-227 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-228 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-229 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-230 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-231 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-232 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-233 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-234 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-235 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-236 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-237 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-238 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-239 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-240 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-241 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-242 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-243 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-244 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-245 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-246 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-247 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-248 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-249 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-250 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - - 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-251 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-252 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ LEFT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - - - 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+}
+do_execsql_test joinB-253 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-254 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ LEFT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - - 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-255 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ LEFT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - - 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - - 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-256 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL LEFT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-257 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-258 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-259 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-260 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-261 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-262 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-263 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-264 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-265 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-266 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 18 - 38 38 - 38
+}
+do_execsql_test joinB-267 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-268 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-269 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-270 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-271 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-272 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-273 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-274 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-275 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-276 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-277 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-278 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-279 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-280 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-281 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-282 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 18 - 38 38 - 38
+ 19 - - - 39 39
+}
+do_execsql_test joinB-283 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-284 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-285 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-286 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-287 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-288 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-289 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-290 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-291 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-292 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-293 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-294 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-295 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-296 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-297 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-298 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 18 - 38 38 - 38
+}
+do_execsql_test joinB-299 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-300 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-301 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-302 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-303 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-304 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-305 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-306 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-307 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-308 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-309 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-310 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-311 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-312 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-313 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-314 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 18 - 38 38 - 38
+ 19 - - - 39 39
+}
+do_execsql_test joinB-315 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-316 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - - 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-317 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-318 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-319 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - - 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-320 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-321 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-322 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-323 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-324 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-325 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-326 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-327 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-328 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-329 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-330 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-331 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-332 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-333 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-334 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-335 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-336 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-337 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-338 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-339 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-340 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-341 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-342 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-343 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-344 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-345 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-346 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-347 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-348 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-349 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-350 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-351 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-352 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-353 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-354 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-355 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-356 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-357 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-358 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-359 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-360 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-361 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-362 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-363 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-364 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-365 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-366 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-367 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-368 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-369 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-370 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-371 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-372 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-373 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-374 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-375 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 - - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-376 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-377 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-378 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 - - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-379 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-380 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-381 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-382 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ RIGHT JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-383 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ RIGHT JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 - - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-384 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL RIGHT JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-385 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-386 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-387 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-388 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-389 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-390 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-391 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-392 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-393 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-394 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+}
+do_execsql_test joinB-395 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-396 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-397 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-398 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-399 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-400 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-401 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-402 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-403 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-404 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-405 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-406 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-407 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-408 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-409 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-410 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - - 39 39
+}
+do_execsql_test joinB-411 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-412 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 INNER JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-413 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-414 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ INNER JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-415 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ INNER JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-416 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL INNER JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-417 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-418 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-419 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+}
+do_execsql_test joinB-420 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-421 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-422 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-423 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-424 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-425 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-426 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+}
+do_execsql_test joinB-427 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+}
+do_execsql_test joinB-428 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-429 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-430 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - - 39
+}
+do_execsql_test joinB-431 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - - 19
+}
+do_execsql_test joinB-432 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-433 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-434 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - - 39 39
+}
+do_execsql_test joinB-435 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - - 19 19
+}
+do_execsql_test joinB-436 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-437 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-438 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-439 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-440 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-441 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-442 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - - 39 39
+}
+do_execsql_test joinB-443 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-444 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 LEFT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - - 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - - - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-445 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-446 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ LEFT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - - 39 39
+}
+do_execsql_test joinB-447 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ LEFT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - - 19 19
+}
+do_execsql_test joinB-448 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL LEFT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-449 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-450 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-451 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-452 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-453 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-454 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-455 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-456 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-457 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-458 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-459 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-460 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-461 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-462 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-463 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-464 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-465 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-466 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-467 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-468 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-469 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-470 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-471 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-472 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-473 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-474 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-475 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-476 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 RIGHT JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-477 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-478 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ RIGHT JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-479 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ RIGHT JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-480 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL RIGHT JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-481 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-482 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-483 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-484 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ INNER JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-485 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-486 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ INNER JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-487 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ INNER JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-488 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL INNER JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-489 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-490 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-491 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-492 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ LEFT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-493 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-494 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ LEFT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-495 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ LEFT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-496 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL LEFT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-497 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-498 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-499 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-500 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ RIGHT JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+}
+do_execsql_test joinB-501 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-502 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ RIGHT JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 - - - - 37
+ 18 28 - - - - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-503 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ RIGHT JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 - - - - 17
+ 18 - - - - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-504 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL RIGHT JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+do_execsql_test joinB-505 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ INNER JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-506 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ INNER JOIN t5 USING(a,b)
+ WHERE a<>13
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 35 35 35 35 35
+ 17 37 - 37 - 37
+ 18 - 38 38 - 38
+ 19 - - 39 39 39
+}
+do_execsql_test joinB-507 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ LEFT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-508 {
+ SELECT a, c, d, e, f, g
+ FROM t1
+ FULL JOIN (t2 FULL JOIN t3 USING(a)) USING(a)
+ FULL JOIN (t4 LEFT JOIN t5 USING(a)) USING(a)
+ WHERE a<=18
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 31 - 31 31 -
+ 12 32 32 32 - -
+ 13 - 33 33 33 -
+ 15 35 35 35 35 35
+ 17 37 - 37 - -
+ 18 - 38 38 - -
+}
+do_execsql_test joinB-509 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ RIGHT JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-510 {
+ SELECT a, b, c, d, e, f, g
+ FROM t1
+ FULL JOIN t2 USING(a,b)
+ FULL JOIN t3 USING(a,b)
+ FULL JOIN t4 USING(a,b)
+ RIGHT JOIN t5 USING(a,b)
+ WHERE d<>33 OR d IS NULL
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 25 35 35 35 35 35
+ 17 27 37 - 37 - 37
+ 18 28 - 38 38 - 38
+ 19 29 - - 39 39 39
+}
+do_execsql_test joinB-511 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1
+ FULL JOIN t2 USING(a)
+ FULL JOIN t3 USING(a)
+ FULL JOIN t4 USING(a)
+ FULL JOIN t5 USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+}
+do_execsql_test joinB-512 {
+ SELECT b, c, d, e, f, g
+ FROM t1
+ NATURAL FULL JOIN t2
+ NATURAL FULL JOIN t3
+ NATURAL FULL JOIN t4
+ NATURAL FULL JOIN t5
+ WHERE b BETWEEN 12 AND 17
+ ORDER BY 1 NULLS FIRST;
+} {
+}
+finish_test
+
+##############################################################################
+# Here is the original TCL script that generated the psql input file:
+#
+#
+# puts "
+# \\pset border off
+# \\pset tuples_only on
+# \\pset null -
+#
+# DROP TABLE IF EXISTS t1;
+# DROP TABLE IF EXISTS t2;
+# DROP TABLE IF EXISTS t3;
+# DROP TABLE IF EXISTS t4;
+# DROP TABLE IF EXISTS t5;
+# CREATE TABLE t1(a INT, b INT, c INT);
+# CREATE TABLE t2(a INT, b INT, d INT);
+# CREATE TABLE t3(a INT, b INT, e INT);
+# CREATE TABLE t4(a INT, b INT, f INT);
+# CREATE TABLE t5(a INT, b INT, g INT);
+# INSERT INTO t1 VALUES(11,21,31),(12,22,32),(15,25,35),(17,27,37);
+# INSERT INTO t2 VALUES(12,22,32),(13,23,33),(15,25,35),(18,28,38),(NULL,NULL,36);
+# INSERT INTO t4 VALUES(11,21,31),(13,23,33),(15,25,35),(19,29,39);
+# INSERT INTO t3 SELECT * FROM t1 UNION SELECT * FROM t2 UNION SELECT * FROM t4;
+# INSERT INTO t5 SELECT * FROM t3 WHERE a>=15;
+# "
+#
+# proc echo {prefix txt} {
+# regsub -all {\n} $txt \n$prefix txt
+# puts "$prefix$txt"
+# }
+#
+# set n 0
+# set k 0
+# foreach j1 {INNER LEFT RIGHT FULL} {
+# foreach j2 {INNER LEFT RIGHT FULL} {
+# foreach j3 {INNER LEFT RIGHT FULL} {
+# foreach j4 {INNER LEFT RIGHT FULL} {
+#
+# incr n
+# incr k
+# set q1 ""
+# append q1 "SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a\n"
+# append q1 " FROM t1\n"
+# append q1 " $j1 JOIN t2 USING(a)\n"
+# append q1 " $j2 JOIN t3 USING(a)\n"
+# append q1 " $j3 JOIN t4 USING(a)\n"
+# append q1 " $j4 JOIN t5 USING(a)\n"
+# append q1 " ORDER BY 1 NULLS FIRST;"
+#
+# echo "\\qecho " "do_execsql_test joinB-$n \{"
+# echo "\\qecho X " $q1
+# echo "\\qecho " "\} \{"
+# puts $q1
+# echo "\\qecho " "\}"
+#
+# switch [expr {$k%4}] {
+# 0 {
+# set q2 ""
+# append q2 "SELECT b, c, d, e, f, g\n"
+# append q2 " FROM t1\n"
+# append q2 " NATURAL $j1 JOIN t2\n"
+# append q2 " NATURAL $j2 JOIN t3\n"
+# append q2 " NATURAL $j3 JOIN t4\n"
+# append q2 " NATURAL $j4 JOIN t5\n"
+# append q2 " WHERE b BETWEEN 12 AND 17\n"
+# append q2 " ORDER BY 1 NULLS FIRST;"
+# incr n
+# echo "\\qecho " "do_execsql_test joinB-$n \{"
+# echo "\\qecho X " $q2
+# echo "\\qecho " "\} \{"
+# puts $q2
+# echo "\\qecho " "\}"
+# }
+# 1 {
+# set q2 ""
+# append q2 "SELECT a, c, d, e, f, g\n"
+# append q2 " FROM t1\n"
+# append q2 " $j1 JOIN t2 USING(a,b)\n"
+# append q2 " $j2 JOIN t3 USING(a,b)\n"
+# append q2 " $j3 JOIN t4 USING(a,b)\n"
+# append q2 " $j4 JOIN t5 USING(a,b)\n"
+# append q2 " WHERE a<>13\n"
+# append q2 " ORDER BY 1 NULLS FIRST;"
+# incr n
+# echo "\\qecho " "do_execsql_test joinB-$n \{"
+# echo "\\qecho X " $q2
+# echo "\\qecho " "\} \{"
+# puts $q2
+# echo "\\qecho " "\}"
+# }
+# 2 {
+# set q2 ""
+# append q2 "SELECT a, c, d, e, f, g\n"
+# append q2 " FROM t1\n"
+# append q2 " $j1 JOIN (t2 $j2 JOIN t3 USING(a)) USING(a)\n"
+# append q2 " $j3 JOIN (t4 $j4 JOIN t5 USING(a)) USING(a)\n"
+# append q2 " WHERE a<=18\n"
+# append q2 " ORDER BY 1 NULLS FIRST;"
+# incr n
+# echo "\\qecho " "do_execsql_test joinB-$n \{"
+# echo "\\qecho X " $q2
+# echo "\\qecho " "\} \{"
+# puts $q2
+# echo "\\qecho " "\}"
+# }
+# 3 {
+# set q2 ""
+# append q2 "SELECT a, b, c, d, e, f, g\n"
+# append q2 " FROM t1\n"
+# append q2 " $j1 JOIN t2 USING(a,b)\n"
+# append q2 " $j2 JOIN t3 USING(a,b)\n"
+# append q2 " $j3 JOIN t4 USING(a,b)\n"
+# append q2 " $j4 JOIN t5 USING(a,b)\n"
+# append q2 " WHERE d<>33 OR d IS NULL\n"
+# append q2 " ORDER BY 1 NULLS FIRST;"
+# incr n
+# echo "\\qecho " "do_execsql_test joinB-$n \{"
+# echo "\\qecho X " $q2
+# echo "\\qecho " "\} \{"
+# puts $q2
+# echo "\\qecho " "\}"
+# }
+# }
+#
+# }
+# }
+# }
+# }
+##############################################################################
diff --git a/test/joinC.test b/test/joinC.test
new file mode 100644
index 0000000000..a6f9395851
--- /dev/null
+++ b/test/joinC.test
@@ -0,0 +1,4594 @@
+# 2022-04-19
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file implements tests for JOINs.
+#
+# The test case output is all generated by PostgreSQL 14. This test module
+# was created as follows:
+#
+# 1. Run a TCL script (included at the bottom of this file) that
+# generates an input script for "psql" that will run man
+# diverse tests on joins.
+#
+# 2. Run the script from step (1) through psql and collect the
+# output.
+#
+# 3. Make a few minor global search-and-replace operations to convert
+# the psql output into a form suitable for this test module.
+#
+# 4. Add this header, and the script content at the footer.
+#
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+db nullvalue -
+db eval {
+ DROP TABLE IF EXISTS t1;
+ DROP TABLE IF EXISTS t2;
+ DROP TABLE IF EXISTS t3;
+ DROP TABLE IF EXISTS t4;
+ DROP TABLE IF EXISTS t5;
+ CREATE TABLE t1(a INT, b INT, c INT);
+ CREATE TABLE t2(a INT, b INT, d INT);
+ CREATE TABLE t3(a INT, b INT, e INT);
+ CREATE TABLE t4(a INT, b INT, f INT);
+ CREATE TABLE t5(a INT, b INT, g INT);
+ INSERT INTO t1 VALUES(11,21,31),(12,22,32),(15,25,35),(17,27,37);
+ INSERT INTO t2 VALUES(12,22,32),(13,23,33),(15,25,35),(18,28,38),
+ (NULL,NULL,36);
+ INSERT INTO t4 VALUES(11,21,31),(13,23,33),(15,25,35),(19,29,39);
+ INSERT INTO t3 SELECT * FROM t1 UNION SELECT * FROM t2 UNION SELECT * FROM t4;
+ INSERT INTO t5 SELECT * FROM t3 WHERE a>=15;
+}
+do_execsql_test joinC-1 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-2 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-3 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-4 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-5 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-6 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-7 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-8 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-9 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-10 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-11 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-12 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-13 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-14 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-15 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-16 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-17 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-18 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-19 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-20 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-21 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-22 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-23 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-24 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-25 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-26 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-27 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-28 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-29 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-30 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-31 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-32 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-33 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-34 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-35 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-36 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-37 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-38 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-39 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-40 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-41 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-42 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-43 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-44 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-45 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-46 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-47 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-48 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-49 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-50 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-51 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-52 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-53 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-54 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-55 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-56 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-57 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-58 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-59 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-60 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-61 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-62 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-63 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-64 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 INNER JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-65 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-66 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-67 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-68 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-69 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-70 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-71 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-72 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-73 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-74 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-75 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-76 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-77 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-78 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-79 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-80 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-81 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-82 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-83 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-84 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-85 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-86 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-87 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-88 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-89 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-90 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-91 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-92 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-93 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-94 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-95 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-96 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-97 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-98 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-99 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-100 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-101 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-102 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-103 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-104 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-105 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-106 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-107 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-108 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-109 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-110 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-111 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-112 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-113 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-114 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-115 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-116 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-117 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-118 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-119 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-120 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-121 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-122 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-123 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-124 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-125 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-126 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+
+}
+do_execsql_test joinC-127 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-128 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 LEFT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+
+}
+do_execsql_test joinC-129 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-130 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-131 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-132 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-133 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-134 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-135 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-136 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-137 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-138 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+
+}
+do_execsql_test joinC-139 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-140 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-141 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-142 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-143 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-144 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-145 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-146 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-147 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-148 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-149 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-150 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-151 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-152 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-153 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-154 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-155 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-156 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-157 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-158 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-159 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-160 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-161 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-162 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-163 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-164 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-165 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-166 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-167 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-168 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-169 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-170 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-171 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-172 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-173 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-174 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-175 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-176 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-177 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-178 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-179 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-180 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-181 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-182 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-183 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-184 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-185 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-186 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-187 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-188 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-189 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-190 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-191 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-192 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 RIGHT JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-193 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-194 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-195 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-196 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-197 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-198 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-199 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-200 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-201 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-202 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+
+}
+do_execsql_test joinC-203 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-204 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-205 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-206 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-207 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-208 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 INNER JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-209 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-210 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-211 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-212 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-213 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-214 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-215 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-216 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-217 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-218 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+
+}
+do_execsql_test joinC-219 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-220 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-221 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-222 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - -
+
+}
+do_execsql_test joinC-223 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-224 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 LEFT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 18 - 18
+
+}
+do_execsql_test joinC-225 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-226 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-227 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-228 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-229 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-230 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-231 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-232 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-233 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-234 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-235 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - - - -
+ 12 12 - - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-236 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ 11 11 - 11 11 -
+ 12 12 - - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-237 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-238 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-239 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-240 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 RIGHT JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-241 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-242 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-243 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-244 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 INNER JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-245 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-246 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-247 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-248 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 LEFT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-249 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-250 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - - - -
+ 18 - 18 - - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-251 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - - - -
+ 12 12 12 - - -
+ 13 - 13 - - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-252 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 RIGHT JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 - - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-253 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 INNER JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-254 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 LEFT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - -
+ 18 - 18 18 - -
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-255 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 RIGHT JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 - -
+ 12 12 12 12 - -
+ 13 - 13 13 - -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+do_execsql_test joinC-256 {
+ SELECT a, t1.a, t2.a, t3.a, t4.a, t5.a
+ FROM t1 FULL JOIN (
+ t2 FULL JOIN (
+ t3 FULL JOIN (
+ t4 FULL JOIN t5 USING(a)
+ ) USING(a)
+ ) USING(a)
+ ) USING(a)
+ ORDER BY 1 NULLS FIRST;
+} {
+ - - - - - -
+ - - - - - -
+ 11 11 - 11 11 -
+ 12 12 12 12 - -
+ 13 - 13 13 13 -
+ 15 15 15 15 15 15
+ 17 17 - 17 - 17
+ 18 - 18 18 - 18
+ 19 - - 19 19 19
+
+}
+finish_test
diff --git a/test/joinD.test b/test/joinD.test
new file mode 100644
index 0000000000..aba1d62800
--- /dev/null
+++ b/test/joinD.test
@@ -0,0 +1,2998 @@
+# 2022-05-04
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+# May you do good and not evil.
+# May you find forgiveness for yourself and forgive others.
+# May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file implements tests for JOINs that use Bloom filters.
+#
+# The test case output is (mostly) all generated by PostgreSQL 14. This
+# test module was created as follows:
+#
+# 1. Run a TCL script (included at the bottom of this file) that
+# generates an input script for "psql" that will run man
+# diverse tests on joins.
+#
+# 2. Run the script from step (1) through psql and collect the
+# output.
+#
+# 3. Make a few minor global search-and-replace operations to convert
+# the psql output into a form suitable for this test module.
+#
+# 4. Add this header, and the script content at the footer.
+#
+# A few extra tests that were not generated from postgresql output are
+# added at the end.
+#
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+db nullvalue -
+db eval {
+ CREATE TABLE t1(a INT, b INT, c INT, d INT);
+ WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x+1 FROM c WHERE x<95)
+ INSERT INTO t1(a,b,c,d) SELECT x, x+100, x+200, x+300 FROM c;
+ CREATE TABLE t2(b INT, x INT);
+ INSERT INTO t2(b,x) SELECT b, a FROM t1 WHERE a%2=0;
+ CREATE INDEX t2b ON t2(b);
+ CREATE TABLE t3(c INT, y INT);
+ INSERT INTO t3(c,y) SELECT c, a FROM t1 WHERE a%3=0;
+ CREATE INDEX t3c ON t3(c);
+ CREATE TABLE t4(d INT, z INT);
+ INSERT INTO t4(d,z) SELECT d, a FROM t1 WHERE a%5=0;
+ CREATE INDEX t4d ON t4(d);
+ INSERT INTO t1(a,b,c,d) VALUES
+ (96,NULL,296,396),
+ (97,197,NULL,397),
+ (98,198,298,NULL),
+ (99,NULL,NULL,NULL);
+ ANALYZE;
+}
+do_execsql_test joinD-1 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-2 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-3 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-4 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-5 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-6 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+}
+do_execsql_test joinD-7 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-8 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-9 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-10 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+}
+do_execsql_test joinD-11 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-12 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-13 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-14 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+}
+do_execsql_test joinD-15 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-16 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-17 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-18 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+}
+do_execsql_test joinD-19 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-20 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-21 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+}
+do_execsql_test joinD-22 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+}
+do_execsql_test joinD-23 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-24 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-25 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-26 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+ - - - - - - 200 0 - -
+}
+do_execsql_test joinD-27 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-28 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+ - - - - - - 200 0 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-29 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+}
+do_execsql_test joinD-30 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - - - 200 0 - -
+}
+do_execsql_test joinD-31 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-32 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 LEFT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - - - 200 0 - -
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-33 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-34 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-35 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-36 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-37 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-38 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - 100 0 - - - -
+}
+do_execsql_test joinD-39 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-40 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - 100 0 - - - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-41 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-42 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+}
+do_execsql_test joinD-43 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ 60 160 260 360 160 60 260 60 360 60
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-44 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 6 106 206 306 106 6 206 6 - -
+ 12 112 212 312 112 12 212 12 - -
+ 18 118 218 318 118 18 218 18 - -
+ 24 124 224 324 124 24 224 24 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 36 136 236 336 136 36 236 36 - -
+ 42 142 242 342 142 42 242 42 - -
+ 48 148 248 348 148 48 248 48 - -
+ 54 154 254 354 154 54 254 54 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 66 166 266 366 166 66 266 66 - -
+ 72 172 272 372 172 72 272 72 - -
+ 78 178 278 378 178 78 278 78 - -
+ 84 184 284 384 184 84 284 84 - -
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 315 15
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 345 45
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 375 75
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-45 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-46 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - 100 0 - - - -
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+}
+do_execsql_test joinD-47 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 10 110 210 310 110 10 - - 310 10
+ 20 120 220 320 120 20 - - 320 20
+ 30 130 230 330 130 30 230 30 330 30
+ 40 140 240 340 140 40 - - 340 40
+ 50 150 250 350 150 50 - - 350 50
+ 60 160 260 360 160 60 260 60 360 60
+ 70 170 270 370 170 70 - - 370 70
+ 80 180 280 380 180 80 - - 380 80
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-48 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 RIGHT JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 2 102 202 302 102 2 - - - -
+ 4 104 204 304 104 4 - - - -
+ 6 106 206 306 106 6 206 6 - -
+ 8 108 208 308 108 8 - - - -
+ 10 110 210 310 110 10 - - 310 10
+ 12 112 212 312 112 12 212 12 - -
+ 14 114 214 314 114 14 - - - -
+ 16 116 216 316 116 16 - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 20 120 220 320 120 20 - - 320 20
+ 22 122 222 322 122 22 - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 26 126 226 326 126 26 - - - -
+ 28 128 228 328 128 28 - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 32 132 232 332 132 32 - - - -
+ 34 134 234 334 134 34 - - - -
+ 36 136 236 336 136 36 236 36 - -
+ 38 138 238 338 138 38 - - - -
+ 40 140 240 340 140 40 - - 340 40
+ 42 142 242 342 142 42 242 42 - -
+ 44 144 244 344 144 44 - - - -
+ 46 146 246 346 146 46 - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 50 150 250 350 150 50 - - 350 50
+ 52 152 252 352 152 52 - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 56 156 256 356 156 56 - - - -
+ 58 158 258 358 158 58 - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 62 162 262 362 162 62 - - - -
+ 64 164 264 364 164 64 - - - -
+ 66 166 266 366 166 66 266 66 - -
+ 68 168 268 368 168 68 - - - -
+ 70 170 270 370 170 70 - - 370 70
+ 72 172 272 372 172 72 272 72 - -
+ 74 174 274 374 174 74 - - - -
+ 76 176 276 376 176 76 - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 80 180 280 380 180 80 - - 380 80
+ 82 182 282 382 182 82 - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 86 186 286 386 186 86 - - - -
+ 88 188 288 388 188 88 - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 92 192 292 392 192 92 - - - -
+ 94 194 294 394 194 94 - - - -
+ - - - - 100 0 - - - -
+ - - - - - - 200 0 - -
+ - - - - - - 203 3 - -
+ - - - - - - 209 9 - -
+ - - - - - - 215 15 - -
+ - - - - - - 221 21 - -
+ - - - - - - 227 27 - -
+ - - - - - - 233 33 - -
+ - - - - - - 239 39 - -
+ - - - - - - 245 45 - -
+ - - - - - - 251 51 - -
+ - - - - - - 257 57 - -
+ - - - - - - 263 63 - -
+ - - - - - - 269 69 - -
+ - - - - - - 275 75 - -
+ - - - - - - 281 81 - -
+ - - - - - - 287 87 - -
+ - - - - - - 293 93 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 315 15
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 345 45
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 375 75
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-49 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-50 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+}
+do_execsql_test joinD-51 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-52 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ INNER JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-53 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+}
+do_execsql_test joinD-54 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - 100 0 - - - -
+}
+do_execsql_test joinD-55 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-56 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ LEFT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - 100 0 - - - -
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-57 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+}
+do_execsql_test joinD-58 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+ - - - - - - 200 0 - -
+}
+do_execsql_test joinD-59 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 15 115 215 315 - - 215 15 315 15
+ 30 130 230 330 130 30 230 30 330 30
+ 45 145 245 345 - - 245 45 345 45
+ 60 160 260 360 160 60 260 60 360 60
+ 75 175 275 375 - - 275 75 375 75
+ 90 190 290 390 190 90 290 90 390 90
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-60 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 3 103 203 303 - - 203 3 - -
+ 6 106 206 306 106 6 206 6 - -
+ 9 109 209 309 - - 209 9 - -
+ 12 112 212 312 112 12 212 12 - -
+ 15 115 215 315 - - 215 15 315 15
+ 18 118 218 318 118 18 218 18 - -
+ 21 121 221 321 - - 221 21 - -
+ 24 124 224 324 124 24 224 24 - -
+ 27 127 227 327 - - 227 27 - -
+ 30 130 230 330 130 30 230 30 330 30
+ 33 133 233 333 - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ 39 139 239 339 - - 239 39 - -
+ 42 142 242 342 142 42 242 42 - -
+ 45 145 245 345 - - 245 45 345 45
+ 48 148 248 348 148 48 248 48 - -
+ 51 151 251 351 - - 251 51 - -
+ 54 154 254 354 154 54 254 54 - -
+ 57 157 257 357 - - 257 57 - -
+ 60 160 260 360 160 60 260 60 360 60
+ 63 163 263 363 - - 263 63 - -
+ 66 166 266 366 166 66 266 66 - -
+ 69 169 269 369 - - 269 69 - -
+ 72 172 272 372 172 72 272 72 - -
+ 75 175 275 375 - - 275 75 375 75
+ 78 178 278 378 178 78 278 78 - -
+ 81 181 281 381 - - 281 81 - -
+ 84 184 284 384 184 84 284 84 - -
+ 87 187 287 387 - - 287 87 - -
+ 90 190 290 390 190 90 290 90 390 90
+ 93 193 293 393 - - 293 93 - -
+ - - - - - - 200 0 - -
+ - - - - - - - - 300 0
+ - - - - - - - - 305 5
+ - - - - - - - - 310 10
+ - - - - - - - - 320 20
+ - - - - - - - - 325 25
+ - - - - - - - - 335 35
+ - - - - - - - - 340 40
+ - - - - - - - - 350 50
+ - - - - - - - - 355 55
+ - - - - - - - - 365 65
+ - - - - - - - - 370 70
+ - - - - - - - - 380 80
+ - - - - - - - - 385 85
+ - - - - - - - - 395 95
+}
+do_execsql_test joinD-61 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ INNER JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+}
+do_execsql_test joinD-62 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - 100 0 - - - -
+ - - - - - - 200 0 - -
+}
+do_execsql_test joinD-63 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ RIGHT JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 5 105 205 305 - - - - 305 5
+ 10 110 210 310 110 10 - - 310 10
+ 15 115 215 315 - - 215 15 315 15
+ 20 120 220 320 120 20 - - 320 20
+ 25 125 225 325 - - - - 325 25
+ 30 130 230 330 130 30 230 30 330 30
+ 35 135 235 335 - - - - 335 35
+ 40 140 240 340 140 40 - - 340 40
+ 45 145 245 345 - - 245 45 345 45
+ 50 150 250 350 150 50 - - 350 50
+ 55 155 255 355 - - - - 355 55
+ 60 160 260 360 160 60 260 60 360 60
+ 65 165 265 365 - - - - 365 65
+ 70 170 270 370 170 70 - - 370 70
+ 75 175 275 375 - - 275 75 375 75
+ 80 180 280 380 180 80 - - 380 80
+ 85 185 285 385 - - - - 385 85
+ 90 190 290 390 190 90 290 90 390 90
+ 95 195 295 395 - - - - 395 95
+ - - - - - - - - 300 0
+}
+do_execsql_test joinD-64 {
+ SELECT t1.*, t2.*, t3.*, t4.*
+ FROM t1 FULL JOIN t2 ON t1.b=t2.b AND t2.x>0
+ FULL JOIN t3 ON t1.c=t3.c AND t3.y>0
+ FULL JOIN t4 ON t1.d=t4.d AND t4.z>0
+ ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);
+} {
+ 0 100 200 300 - - - - - -
+ 1 101 201 301 - - - - - -
+ 2 102 202 302 102 2 - - - -
+ 3 103 203 303 - - 203 3 - -
+ 4 104 204 304 104 4 - - - -
+ 5 105 205 305 - - - - 305 5
+ 6 106 206 306 106 6 206 6 - -
+ 7 107 207 307 - - - - - -
+ 8 108 208 308 108 8 - - - -
+ 9 109 209 309 - - 209 9 - -
+ 10 110 210 310 110 10 - - 310 10
+ 11 111 211 311 - - - - - -
+ 12 112 212 312 112 12 212 12 - -
+ 13 113 213 313 - - - - - -
+ 14 114 214 314 114 14 - - - -
+ 15 115 215 315 - - 215 15 315 15
+ 16 116 216 316 116 16 - - - -
+ 17 117 217 317 - - - - - -
+ 18 118 218 318 118 18 218 18 - -
+ 19 119 219 319 - - - - - -
+ 20 120 220 320 120 20 - - 320 20
+ 21 121 221 321 - - 221 21 - -
+ 22 122 222 322 122 22 - - - -
+ 23 123 223 323 - - - - - -
+ 24 124 224 324 124 24 224 24 - -
+ 25 125 225 325 - - - - 325 25
+ 26 126 226 326 126 26 - - - -
+ 27 127 227 327 - - 227 27 - -
+ 28 128 228 328 128 28 - - - -
+ 29 129 229 329 - - - - - -
+ 30 130 230 330 130 30 230 30 330 30
+ 31 131 231 331 - - - - - -
+ 32 132 232 332 132 32 - - - -
+ 33 133 233 333 - - 233 33 - -
+ 34 134 234 334 134 34 - - - -
+ 35 135 235 335 - - - - 335 35
+ 36 136 236 336 136 36 236 36 - -
+ 37 137 237 337 - - - - - -
+ 38 138 238 338 138 38 - - - -
+ 39 139 239 339 - - 239 39 - -
+ 40 140 240 340 140 40 - - 340 40
+ 41 141 241 341 - - - - - -
+ 42 142 242 342 142 42 242 42 - -
+ 43 143 243 343 - - - - - -
+ 44 144 244 344 144 44 - - - -
+ 45 145 245 345 - - 245 45 345 45
+ 46 146 246 346 146 46 - - - -
+ 47 147 247 347 - - - - - -
+ 48 148 248 348 148 48 248 48 - -
+ 49 149 249 349 - - - - - -
+ 50 150 250 350 150 50 - - 350 50
+ 51 151 251 351 - - 251 51 - -
+ 52 152 252 352 152 52 - - - -
+ 53 153 253 353 - - - - - -
+ 54 154 254 354 154 54 254 54 - -
+ 55 155 255 355 - - - - 355 55
+ 56 156 256 356 156 56 - - - -
+ 57 157 257 357 - - 257 57 - -
+ 58 158 258 358 158 58 - - - -
+ 59 159 259 359 - - - - - -
+ 60 160 260 360 160 60 260 60 360 60
+ 61 161 261 361 - - - - - -
+ 62 162 262 362 162 62 - - - -
+ 63 163 263 363 - - 263 63 - -
+ 64 164 264 364 164 64 - - - -
+ 65 165 265 365 - - - - 365 65
+ 66 166 266 366 166 66 266 66 - -
+ 67 167 267 367 - - - - - -
+ 68 168 268 368 168 68 - - - -
+ 69 169 269 369 - - 269 69 - -
+ 70 170 270 370 170 70 - - 370 70
+ 71 171 271 371 - - - - - -
+ 72 172 272 372 172 72 272 72 - -
+ 73 173 273 373 - - - - - -
+ 74 174 274 374 174 74 - - - -
+ 75 175 275 375 - - 275 75 375 75
+ 76 176 276 376 176 76 - - - -
+ 77 177 277 377 - - - - - -
+ 78 178 278 378 178 78 278 78 - -
+ 79 179 279 379 - - - - - -
+ 80 180 280 380 180 80 - - 380 80
+ 81 181 281 381 - - 281 81 - -
+ 82 182 282 382 182 82 - - - -
+ 83 183 283 383 - - - - - -
+ 84 184 284 384 184 84 284 84 - -
+ 85 185 285 385 - - - - 385 85
+ 86 186 286 386 186 86 - - - -
+ 87 187 287 387 - - 287 87 - -
+ 88 188 288 388 188 88 - - - -
+ 89 189 289 389 - - - - - -
+ 90 190 290 390 190 90 290 90 390 90
+ 91 191 291 391 - - - - - -
+ 92 192 292 392 192 92 - - - -
+ 93 193 293 393 - - 293 93 - -
+ 94 194 294 394 194 94 - - - -
+ 95 195 295 395 - - - - 395 95
+ 96 - 296 396 - - - - - -
+ 97 197 - 397 - - - - - -
+ 98 198 298 - - - - - - -
+ 99 - - - - - - - - -
+ - - - - 100 0 - - - -
+ - - - - - - 200 0 - -
+ - - - - - - - - 300 0
+}
+
+#############################################################################
+# The following are extra tests added manually
+
+do_execsql_test joinD-1000 {
+ CREATE VIEW v1 AS
+ SELECT *
+ FROM t1 INNER JOIN t2 ON t1.b=t2.b AND t2.x>0
+ RIGHT JOIN t3 ON t1.c=t3.c AND t3.y>0
+ LEFT JOIN t4 ON t1.d=t4.d AND t4.z>0;
+ CREATE TRIGGER v1r1 INSTEAD OF UPDATE OF c ON v1 BEGIN
+ UPDATE t1 SET c=new.c WHERE (a,b,c,d) IS (old.a,old.b,old.c,old.d);
+ UPDATE t3 SET c=new.c WHERE (c,y) IS (old.c,old.y);
+ END;
+ SELECT * FROM v1 WHERE y BETWEEN 30 AND 40 ORDER BY y;
+} {
+ 30 130 230 330 130 30 230 30 330 30
+ - - - - - - 233 33 - -
+ 36 136 236 336 136 36 236 36 - -
+ - - - - - - 239 39 - -
+}
+do_execsql_test joinD-1010 {
+ BEGIN;
+ UPDATE v1 SET c=c+1000 WHERE y BETWEEN 30 and 40;
+ SELECT * FROM v1 WHERE y BETWEEN 30 AND 40 ORDER BY y;
+ ROLLBACK;
+} {
+ 30 130 1230 330 130 30 1230 30 330 30
+ - - - - - - 233 33 - -
+ 36 136 1236 336 136 36 1236 36 - -
+ - - - - - - 239 39 - -
+}
+
+finish_test
+
+#############################################################################
+# This is the TCL script used to generate the psql script that generated
+# the data above.
+#
+# puts "
+# \\pset border off
+# \\pset tuples_only on
+# \\pset null -
+#
+# DROP TABLE IF EXISTS t1;
+# DROP TABLE IF EXISTS t2;
+# DROP TABLE IF EXISTS t3;
+# DROP TABLE IF EXISTS t4;
+# CREATE TABLE t1(a INT, b INT, c INT, d INT);
+# WITH RECURSIVE c(x) AS (VALUES(0) UNION ALL SELECT x+1 FROM c WHERE x<95)
+# INSERT INTO t1(a,b,c,d) SELECT x, x+100, x+200, x+300 FROM c;
+# CREATE TABLE t2(b INT, x INT);
+# INSERT INTO t2(b,x) SELECT b, a FROM t1 WHERE a%2=0;
+# CREATE INDEX t2b ON t2(b);
+# CREATE TABLE t3(c INT, y INT);
+# INSERT INTO t3(c,y) SELECT c, a FROM t1 WHERE a%3=0;
+# CREATE INDEX t3c ON t3(c);
+# CREATE TABLE t4(d INT, z INT);
+# INSERT INTO t4(d,z) SELECT d, a FROM t1 WHERE a%5=0;
+# CREATE INDEX t4d ON t4(d);
+# INSERT INTO t1(a,b,c,d) VALUES
+# (96,NULL,296,396),
+# (97,197,NULL,397),
+# (98,198,298,NULL),
+# (99,NULL,NULL,NULL);
+# "
+#
+# proc echo {prefix txt} {
+# regsub -all {\n} $txt \n$prefix txt
+# puts "$prefix$txt"
+# }
+#
+# set n 0
+# set k 0
+# foreach j1 {INNER LEFT RIGHT FULL} {
+# foreach j2 {INNER LEFT RIGHT FULL} {
+# foreach j3 {INNER LEFT RIGHT FULL} {
+#
+# incr n
+# incr k
+# set q1 ""
+# append q1 "SELECT t1.*, t2.*, t3.*, t4.*\n"
+# append q1 " FROM t1 $j1 JOIN t2 ON t1.b=t2.b AND t2.x>0\n"
+# append q1 " $j2 JOIN t3 ON t1.c=t3.c AND t3.y>0\n"
+# append q1 " $j3 JOIN t4 ON t1.d=t4.d AND t4.z>0\n"
+# append q1 " ORDER BY coalesce(t1.a,t2.b,t3.c,t4.d,0);"
+#
+# echo "\\qecho " "do_execsql_test joinB-$n \{"
+# echo "\\qecho X " $q1
+# echo "\\qecho " "\} \{"
+# puts $q1
+# echo "\\qecho " "\}"
+#
+# }
+# }
+# }
diff --git a/test/json101.test b/test/json101.test
index 1845279179..b84846d888 100644
--- a/test/json101.test
+++ b/test/json101.test
@@ -850,4 +850,21 @@ do_execsql_test json-17.1 {
SELECT * FROM t1 LEFT JOIN t2 ON (SELECT b FROM json_each ORDER BY 1);
} {}
+# 2022-04-04 forum post https://sqlite.org/forum/forumpost/c082aeab43
+do_execsql_test json-18.1 {
+ SELECT json_valid('{"":5}');
+} {1}
+do_execsql_test json-18.2 {
+ SELECT json_extract('{"":5}', '$.""');
+} {5}
+do_execsql_test json-18.3 {
+ SELECT json_extract('[3,{"a":4,"":[5,{"hi":6},7]},8]', '$[1].""[1].hi');
+} {6}
+do_execsql_test json-18.4 {
+ SELECT json_extract('[3,{"a":4,"":[5,{"hi":6},7]},8]', '$[1].""[1]."hi"');
+} {6}
+do_catchsql_test json-18.5 {
+ SELECT json_extract('{"":8}', '$.');
+} {1 {JSON path error near ''}}
+
finish_test
diff --git a/test/select1.test b/test/select1.test
index e22907da1e..44e63d252d 100644
--- a/test/select1.test
+++ b/test/select1.test
@@ -545,14 +545,14 @@ do_test select1-6.9.7 {
set x [execsql2 {
SELECT * FROM test1 a, (select 5, 6) LIMIT 1
}]
- regsub -all {subquery_[0-9a-fA-F_]+} $x {subquery} x
+ regsub -all {subquery-\d+} $x {subquery-0} x
set x
-} {a.f1 11 a.f2 22 subquery.5 5 subquery.6 6}
+} {a.f1 11 a.f2 22 (subquery-0).5 5 (subquery-0).6 6}
do_test select1-6.9.8 {
set x [execsql2 {
SELECT * FROM test1 a, (select 5 AS x, 6 AS y) AS b LIMIT 1
}]
- regsub -all {subquery_[0-9a-fA-F]+_} $x {subquery} x
+ regsub -all {subquery-\d+} $x {subquery-0} x
set x
} {a.f1 11 a.f2 22 b.x 5 b.y 6}
do_test select1-6.9.9 {
diff --git a/test/shell1.test b/test/shell1.test
index cbbadc58c9..3c7061c55d 100644
--- a/test/shell1.test
+++ b/test/shell1.test
@@ -1221,6 +1221,23 @@ do_test shell1-8.4 {
+------------------+-----+
| 6683623321994527 | -47 |
+------------------+-----+}}
+do_test shell1-8.5 {
+ catchcmd ":memory: --box" {
+create table t(a text, b int);
+insert into t values ('too long for one line', 1), ('shorter', NULL);
+.header on
+.width 10 10
+.nullvalue NADA
+select * from t;}
+} {0 {┌────────────┬────────────┐
+│ a │ b │
+├────────────┼────────────┤
+│ too long f │ 1 │
+│ or one lin │ │
+│ e │ │
+├────────────┼────────────┤
+│ shorter │ NADA │
+└────────────┴────────────┘}}
#----------------------------------------------------------------------------
# Test cases shell1-9.*: Basic test that "dot" commands and SQL intermix ok.
diff --git a/test/shell2.test b/test/shell2.test
index db8cd96ab8..29712c7f07 100644
--- a/test/shell2.test
+++ b/test/shell2.test
@@ -188,4 +188,13 @@ b
2
}}
+# Test for rejection of incomplete input at EOF.
+# Reported at https://sqlite.org/forum/forumpost/718f489a43be3197
+do_test shell2-1.4.7 {
+ catchcmd ":memory:" {
+ SELECT 'unclosed;}
+} {1 {Parse error near line 2: unrecognized token: "'unclosed;"
+ SELECT 'unclosed;
+ ^--- error here}}
+
finish_test
diff --git a/test/shell5.test b/test/shell5.test
index d63a0a20d3..00d89f8d78 100644
--- a/test/shell5.test
+++ b/test/shell5.test
@@ -540,4 +540,34 @@ Columns renamed during .import shell5.csv due to duplicates:
"CoW" to "CoW_3",
"cOw" to "cOw_4"}}
+#----------------------------------------------------------------------------
+# Tests for preserving utf-8 that is not also ASCII.
+#
+
+do_test shell5-6.1 {
+ set out [open shell5.csv w]
+ fconfigure $out -translation lf
+ puts $out {あい,うえお}
+ puts $out {1,2}
+ close $out
+ forcedelete test.db
+ catchcmd test.db {.import -csv shell5.csv t1
+.mode line
+SELECT * FROM t1;}
+} {0 { あい = 1
+うえお = 2}}
+
+do_test shell5-6.2 {
+ set out [open shell5.csv w]
+ fconfigure $out -translation lf
+ puts $out {1,2}
+ puts $out {あい,うえお}
+ close $out
+ forcedelete test.db
+ catchcmd test.db {.import -csv shell5.csv t1
+.mode line
+SELECT * FROM t1;}
+} {0 { 1 = あい
+ 2 = うえお}}
+
finish_test
diff --git a/test/tester.tcl b/test/tester.tcl
index 2bef8d37e6..dd6512fe9a 100644
--- a/test/tester.tcl
+++ b/test/tester.tcl
@@ -1012,6 +1012,7 @@ proc query_plan_graph {sql} {
append a [append_graph " " dx cx 0]
regsub -all { 0x[A-F0-9]+\y} $a { xxxxxx} a
regsub -all {(MATERIALIZE|CO-ROUTINE|SUBQUERY) \d+\y} $a {\1 xxxxxx} a
+ regsub -all {\((join|subquery)-\d+\)} $a {(\1-xxxxxx)} a
return $a
}
diff --git a/test/tkt3935.test b/test/tkt3935.test
index abbeb3f866..a4f1f61dad 100644
--- a/test/tkt3935.test
+++ b/test/tkt3935.test
@@ -34,13 +34,13 @@ do_test tkt3935.3 {
do_test tkt3935.4 {
catchsql { SELECT a FROM (t1) AS t ON b USING(a) }
-} {1 {a JOIN clause is required before ON}}
+} {1 {near "USING": syntax error}}
do_test tkt3935.5 {
catchsql { SELECT a FROM (t1) AS t ON b }
} {1 {a JOIN clause is required before ON}}
do_test tkt3935.6 {
catchsql { SELECT a FROM (SELECT * FROM t1) AS t ON b USING(a) }
-} {1 {a JOIN clause is required before ON}}
+} {1 {near "USING": syntax error}}
do_test tkt3935.7 {
catchsql { SELECT a FROM (SELECT * FROM t1) AS t ON b }
} {1 {a JOIN clause is required before ON}}
@@ -49,7 +49,7 @@ do_test tkt3935.8 {
} {1 {a JOIN clause is required before ON}}
do_test tkt3935.9 {
catchsql { SELECT a FROM t1 AS t ON b USING(a) }
-} {1 {a JOIN clause is required before ON}}
+} {1 {near "USING": syntax error}}
do_test tkt3935.10 {
catchsql { SELECT a FROM t1 AS t USING(a) }
} {1 {a JOIN clause is required before USING}}
diff --git a/test/upfrom2.test b/test/upfrom2.test
index a1f00953e6..600fa05e4b 100644
--- a/test/upfrom2.test
+++ b/test/upfrom2.test
@@ -382,4 +382,24 @@ do_execsql_test 6.2 {
)
} {}
+# 2022-03-21
+# https://sqlite.org/forum/forumpost/929168fdd6
+#
+reset_db
+do_execsql_test 7.0 {
+ CREATE TABLE t1(a);
+ INSERT INTO t1(a) VALUES(11),(22),(33),(44),(55);
+ CREATE VIEW t2(b,c) AS SELECT a, COUNT(*) OVER () FROM t1;
+ CREATE TABLE t3(x,y);
+ CREATE TRIGGER t2r1 INSTEAD OF UPDATE ON t2 BEGIN
+ INSERT INTO t3(x,y) VALUES(new.b,new.c);
+ END;
+ SELECT * FROM t2;
+} {11 5 22 5 33 5 44 5 55 5}
+do_execsql_test 7.1 {
+ UPDATE t2 SET c=t1.a FROM t1 WHERE t2.b=t1.a;
+ SELECT * FROM t3;
+} {11 11 22 22 33 33 44 44 55 55}
+
+
finish_test
diff --git a/test/vtab6.test b/test/vtab6.test
index ffbe430c6e..2ee5e27051 100644
--- a/test/vtab6.test
+++ b/test/vtab6.test
@@ -223,11 +223,11 @@ do_test vtab6-2.2 {
SELECT * FROM t2 NATURAL LEFT OUTER JOIN t1;
}
} {1 2 3 {} 2 3 4 1 3 4 5 2}
-do_test vtab6-2.3 {
- catchsql {
- SELECT * FROM t1 NATURAL RIGHT OUTER JOIN t2;
- }
-} {1 {RIGHT and FULL OUTER JOINs are not currently supported}}
+#do_test vtab6-2.3 {
+# catchsql {
+# SELECT * FROM t1 NATURAL RIGHT OUTER JOIN t2;
+# }
+#} {1 {RIGHT and FULL OUTER JOINs are not currently supported}}
do_test vtab6-2.4 {
execsql {
SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.d
@@ -263,7 +263,7 @@ do_test vtab6-3.3 {
catchsql {
SELECT * FROM t1 JOIN t2 ON t1.a=t2.b USING(b);
}
-} {1 {cannot have both ON and USING clauses in the same join}}
+} {1 {near "USING": syntax error}}
do_test vtab6-3.4 {
catchsql {
SELECT * FROM t1 JOIN t2 USING(a);
@@ -281,12 +281,12 @@ do_test vtab6-3.7 {
catchsql {
SELECT * FROM t1 INNER OUTER JOIN t2;
}
-} {1 {unknown or unsupported join type: INNER OUTER}}
+} {1 {unknown join type: INNER OUTER}}
do_test vtab6-3.7 {
catchsql {
SELECT * FROM t1 LEFT BOGUS JOIN t2;
}
-} {1 {unknown or unsupported join type: LEFT BOGUS}}
+} {1 {unknown join type: LEFT BOGUS}}
do_test vtab6-4.1 {
execsql {
diff --git a/test/where.test b/test/where.test
index 8ee57b8b6f..2f53f2cb49 100644
--- a/test/where.test
+++ b/test/where.test
@@ -1348,16 +1348,25 @@ do_execsql_test where-18.1 {
INSERT INTO t181 VALUES(1);
SELECT DISTINCT a FROM t181 LEFT JOIN t182 ON a=b ORDER BY c IS NULL;
} {1}
+do_execsql_test where-18.1rj {
+ SELECT DISTINCT a FROM t182 RIGHT JOIN t181 ON a=b ORDER BY c IS NULL;
+} {1}
do_execsql_test where-18.2 {
SELECT DISTINCT a FROM t181 LEFT JOIN t182 ON a=b ORDER BY +c;
} {1}
do_execsql_test where-18.3 {
SELECT DISTINCT a FROM t181 LEFT JOIN t182 ON a=b ORDER BY c;
} {1}
+do_execsql_test where-18.3rj {
+ SELECT DISTINCT a FROM t182 RIGHT JOIN t181 ON a=b ORDER BY c;
+} {1}
do_execsql_test where-18.4 {
INSERT INTO t181 VALUES(1),(1),(1),(1);
SELECT DISTINCT a FROM t181 LEFT JOIN t182 ON a=b ORDER BY +c;
} {1}
+do_execsql_test where-18.4rj {
+ SELECT DISTINCT a FROM t182 RIGHT JOIN t181 ON a=b ORDER BY +c;
+} {1}
do_execsql_test where-18.5 {
INSERT INTO t181 VALUES(2);
SELECT DISTINCT a FROM t181 LEFT JOIN t182 ON a=b ORDER BY c IS NULL, +a;
diff --git a/test/where9.test b/test/where9.test
index 429708f1fe..4757881532 100644
--- a/test/where9.test
+++ b/test/where9.test
@@ -378,9 +378,9 @@ ifcapable explain {
|--SEARCH t1 USING INTEGER PRIMARY KEY (rowid=?)
`--MULTI-INDEX OR
|--INDEX 1
- | `--SEARCH t2 USING INDEX t2d (d=?)
+ | `--SEARCH t2 USING INDEX t2d (d=?) LEFT-JOIN
`--INDEX 2
- `--SEARCH t2 USING COVERING INDEX t2f (f=?)
+ `--SEARCH t2 USING COVERING INDEX t2f (f=?) LEFT-JOIN
}]
}
diff --git a/test/windowB.test b/test/windowB.test
index 52221c445c..0a9aef724f 100644
--- a/test/windowB.test
+++ b/test/windowB.test
@@ -365,4 +365,49 @@ do_execsql_test 9.0 {
FROM seps;
} {-22- -22-333- -333-4444- -4444-}
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 10.1 {
+ CREATE TABLE t1(i INTEGER PRIMARY KEY, v);
+ INSERT INTO t1 VALUES( 1, 'one' );
+ INSERT INTO t1 VALUES( 2, 'two' );
+}
+
+do_execsql_test 10.2 {
+ SELECT
+ json_group_array( v ) OVER w,
+ json_group_array( v ) OVER w
+ FROM t1
+ window w as (
+ range between unbounded preceding and unbounded following
+ )
+} {
+ {["one","two"]}
+ {["one","two"]}
+ {["one","two"]}
+ {["one","two"]}
+}
+
+do_execsql_test 10.3 {
+ SELECT
+ group_concat( v ) OVER w,
+ json_group_array( v ) OVER w,
+ json_group_array( v ) OVER w,
+ group_concat( v ) OVER w
+ FROM t1
+ window w as (
+ range between unbounded preceding and unbounded following
+ )
+} {
+ one,two
+ {["one","two"]}
+ {["one","two"]}
+ one,two
+
+ one,two
+ {["one","two"]}
+ {["one","two"]}
+ one,two
+}
+
finish_test
diff --git a/test/with1.test b/test/with1.test
index 5765399d10..91cbc79524 100644
--- a/test/with1.test
+++ b/test/with1.test
@@ -1075,10 +1075,10 @@ do_execsql_test 21.2 {
# Make sure crazy nexted CTE joins terminate with an error quickly.
#
do_catchsql_test 22.1 {
- WITH RECURSIVE c AS (
- WITH RECURSIVE c AS (
- WITH RECURSIVE c AS (
- WITH RECURSIVE c AS (
+ WITH RECURSIVE c AS NOT MATERIALIZED (
+ WITH RECURSIVE c AS NOT MATERIALIZED (
+ WITH RECURSIVE c AS NOT MATERIALIZED (
+ WITH RECURSIVE c AS NOT MATERIALIZED (
WITH c AS (VALUES(0))
SELECT 1 FROM c LEFT JOIN c ON ltrim(1)
)
diff --git a/test/with6.test b/test/with6.test
index 333147d8be..20e518b01a 100644
--- a/test/with6.test
+++ b/test/with6.test
@@ -229,10 +229,12 @@ do_eqp_test 211 {
} {
QUERY PLAN
|--MATERIALIZE c1
- | |--MATERIALIZE c
+ | |--CO-ROUTINE c
| | `--SCAN 3 CONSTANT ROWS
| `--SCAN c
|--MATERIALIZE c2
+ | |--CO-ROUTINE c
+ | | `--SCAN 3 CONSTANT ROWS
| `--SCAN c
|--SCAN c1
|--SCAN c2
@@ -250,6 +252,71 @@ do_execsql_test 220 {
SELECT y FROM t2 ORDER BY y;
} {40404 40405 40406 40504 40505 40506 40604 40605 40606}
+# 2022-04-22: Do not allow flattening of a MATERIALIZED CTE into
+# an outer query.
+#
+reset_db
+db null -
+do_execsql_test 300 {
+ CREATE TABLE t2(a INT,b INT,d INT); INSERT INTO t2 VALUES(4,5,6),(7,8,9);
+ CREATE TABLE t3(a INT,b INT,e INT); INSERT INTO t3 VALUES(3,3,3),(8,8,8);
+} {}
+do_execsql_test 310 {
+ WITH t23 AS MATERIALIZED (SELECT * FROM t2 FULL JOIN t3 USING(b))
+ SELECT * FROM t23;
+} {
+ 4 5 6 - -
+ 7 8 9 8 8
+ - 3 - 3 3
+}
+do_eqp_test 311 {
+ WITH t23 AS MATERIALIZED (SELECT * FROM t2 FULL JOIN t3 USING(b))
+ SELECT * FROM t23;
+} {
+ QUERY PLAN
+ |--MATERIALIZE t23
+ | |--SCAN t2
+ | |--SCAN t3 LEFT-JOIN
+ | `--RIGHT-JOIN t3
+ | `--SCAN t3
+ `--SCAN t23
+}
+do_execsql_test 320 {
+ WITH t23 AS NOT MATERIALIZED (SELECT * FROM t2 FULL JOIN t3 USING(b))
+ SELECT * FROM t23;
+} {
+ 4 5 6 - -
+ 7 8 9 8 8
+ - 3 - 3 3
+}
+do_eqp_test 321 {
+ WITH t23 AS NOT MATERIALIZED (SELECT * FROM t2 FULL JOIN t3 USING(b))
+ SELECT * FROM t23;
+} {
+ QUERY PLAN
+ |--SCAN t2
+ |--SCAN t3 LEFT-JOIN
+ `--RIGHT-JOIN t3
+ `--SCAN t3
+}
+do_execsql_test 330 {
+ WITH t23 AS (SELECT * FROM t2 FULL JOIN t3 USING(b))
+ SELECT * FROM t23;
+} {
+ 4 5 6 - -
+ 7 8 9 8 8
+ - 3 - 3 3
+}
+do_eqp_test 331 {
+ WITH t23 AS (SELECT * FROM t2 FULL JOIN t3 USING(b))
+ SELECT * FROM t23;
+} {
+ QUERY PLAN
+ |--SCAN t2
+ |--SCAN t3 LEFT-JOIN
+ `--RIGHT-JOIN t3
+ `--SCAN t3
+}
finish_test
diff --git a/tool/lemon.c b/tool/lemon.c
index 11e25c8a1c..fb81292d4d 100644
--- a/tool/lemon.c
+++ b/tool/lemon.c
@@ -3015,6 +3015,7 @@ void Parse(struct lemon *gp)
}
if( c=='/' && cp[1]=='*' ){ /* Skip C style comments */
cp+=2;
+ if( (*cp)=='/' ) cp++;
while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){
if( c=='\n' ) lineno++;
cp++;
diff --git a/tool/mkctimec.tcl b/tool/mkctimec.tcl
index 745a59a229..bc723f4561 100755
--- a/tool/mkctimec.tcl
+++ b/tool/mkctimec.tcl
@@ -158,7 +158,6 @@ set boolean_defnil_options {
SQLITE_ENABLE_QPSG
SQLITE_ENABLE_RBU
SQLITE_ENABLE_RTREE
- SQLITE_ENABLE_SELECTTRACE
SQLITE_ENABLE_SESSION
SQLITE_ENABLE_SNAPSHOT
SQLITE_ENABLE_SORTER_REFERENCES
@@ -166,6 +165,7 @@ set boolean_defnil_options {
SQLITE_ENABLE_STAT4
SQLITE_ENABLE_STMT_SCANSTATUS
SQLITE_ENABLE_STMTVTAB
+ SQLITE_ENABLE_TREETRACE
SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
SQLITE_ENABLE_UNLOCK_NOTIFY
SQLITE_ENABLE_UPDATE_DELETE_LIMIT
diff --git a/tool/mksqlite3c.tcl b/tool/mksqlite3c.tcl
index 1a35fc0ea3..595fc4c602 100644
--- a/tool/mksqlite3c.tcl
+++ b/tool/mksqlite3c.tcl
@@ -291,7 +291,8 @@ proc copy_file {filename} {
# Add the SQLITE_PRIVATE before variable declarations or
# definitions for internal use
regsub {^SQLITE_API } $line {} line
- if {![regexp {^sqlite3_} $varname]} {
+ if {![regexp {^sqlite3_} $varname]
+ && ![regexp {^sqlite3Show[A-Z]} $varname]} {
regsub {^extern } $line {} line
puts $out "SQLITE_PRIVATE $line"
} else {