MB-31034. Support NULLS FIRST|LAST syntax in ORDER BY

1) ORDER BY col1 ASC
       (MISSING, NULL, BOOLEAN, NUMBER, STRING, ARRAY, OBJECT, BINARY)

2) ORDER BY col1 ASC NULLS FIRST  -- This is same as 1st case

3) ORDER BY col1 ASC NULLS LAST
       Both MISSING and NULL values are placed last as MISSING followed by NULL
       (BOOLEAN, NUMBER, STRING, ARRAY, OBJECT, BINARY, MISSING, NULL)

4) ORDER BY col1 DESC
       (BINARY, OBJECT, ARRAY, STRING, NUMBER, BOOLEAN, NULL, MISSING)

5) ORDER BY col1 DESC NULLS FIRST
       Both MISSING and NULL values are placed at start as NULL followed by MISSING
       (NULL, MISSING, BINARY, OBJECT, ARRAY, STRING, NUMBER, BOOLEAN)

6) ORDER BY col1 DESC NULLS LAST   -- This is same as 4th case

Change-Id: I60269c2cce6263d730d255560d997c0402e630b0
Reviewed-on: http://review.couchbase.org/98730
Reviewed-by: Johan Larson <[email protected]>
Tested-by: Sitaram Vemulapalli <[email protected]>

Author: sitaramv

algebra/order.go

@@ -75,16 +75,18 @@ value that decides the sort order (ASC or DESC).
 type SortTerm struct {
 	expr       expression.Expression `json:"expr"`
 	descending bool                  `json:"desc"`
+	nullsPos   bool                  `json:"nulls_pos"`
 }
 
 /*
 The function NewSortTerm returns a pointer to the SortTerm
 struct that has its fields set to the input arguments.
 */
-func NewSortTerm(expr expression.Expression, descending bool) *SortTerm {
+func NewSortTerm(expr expression.Expression, descending, nullsPos bool) *SortTerm {
 	return &SortTerm{
 		expr:       expr,
 		descending: descending,
+		nullsPos:   nullsPos,
 	}
 }
 
@@ -96,6 +98,11 @@ func (this *SortTerm) String() string {
 
 	if this.descending {
 		s += " desc"
+		if this.NullsPos() {
+			s += " NULLS FIRST"
+		}
+	} else if this.NullsPos() {
+		s += " NULLS LAST"
 	}
 
 	return s
@@ -116,6 +123,10 @@ func (this *SortTerm) Descending() bool {
 	return this.descending
 }
 
+func (this *SortTerm) NullsPos() bool {
+	return this.nullsPos
+}
+
 /*
 Map Expressions for all sort terms in the receiver.
 */
@@ -159,3 +170,26 @@ func (this SortTerms) String() string {
 
 	return s
 }
+
+const (
+	ORDER_NULLS_NONE = 1 << iota
+	ORDER_NULLS_FIRST
+	ORDER_NULLS_LAST
+)
+
+func NewOrderNulls(none, nulls, last bool) (r uint32) {
+	if none {
+		r |= ORDER_NULLS_NONE
+	} else if nulls {
+		if last {
+			r |= ORDER_NULLS_LAST
+		} else {
+			r |= ORDER_NULLS_FIRST
+		}
+	}
+	return
+}
+
+func NewOrderNullsPos(descending bool, nulls uint32) bool {
+	return (!descending && (nulls&ORDER_NULLS_LAST) != 0) || (descending && (nulls&ORDER_NULLS_FIRST) != 0)
+}

execution/order.go

@@ -154,7 +154,16 @@ func (this *Order) lessThan(v1 value.AnnotatedValue, v2 value.AnnotatedValue) bo
 			v2.SetAttachment(s, ev2)
 		}
 
-		c = ev1.Collate(ev2)
+		if !term.NullsPos() || ((ev1.Type() <= value.NULL && ev2.Type() <= value.NULL) ||
+			(ev1.Type() > value.NULL && ev2.Type() > value.NULL)) {
+			c = ev1.Collate(ev2)
+		} else {
+			if ev1.Type() <= value.NULL && ev2.Type() > value.NULL {
+				c = 1
+			} else {
+				c = -1
+			}
+		}
 
 		if c == 0 {
 			continue

parser/n1ql/n1ql.nex

@@ -230,6 +230,7 @@
 /[nN][lL]/					 { yylex.logToken(yylex.Text(), "NL"); return NL }
 /[nN][oO][tT]/					 { yylex.logToken(yylex.Text(), "NOT"); return NOT }
 /[nN][uU][lL][lL]/				 { yylex.logToken(yylex.Text(), "NULL"); return NULL }
+/[nN][uU][lL][lL][sS]/				 { yylex.logToken(yylex.Text(), "NULLS"); return NULLS }
 /[nN][uN][mM][bB][eE][rR]/			 { yylex.logToken(yylex.Text(), "NUMBER"); return NUMBER }
 /[oO][bB][jJ][eE][cC][tT]/			 { yylex.logToken(yylex.Text(), "OBJECT"); return OBJECT }
 /[oO][fF][fF][sS][eE][tT]/			 { yylex.logToken(yylex.Text(), "OFFSET"); return OFFSET }