parserTest

3

NumLit "3"

3.

NumLit "3."

3.3

NumLit "3.3"

.3

NumLit ".3"

3.e3

NumLit "3.e3"

3.3e3

NumLit "3.3e3"

.3e3

NumLit ".3e3"

3e3

NumLit "3e3"

3e+3

NumLit "3e+3"

3e-3

NumLit "3e-3"

'string'

StringLit "string"

'string with a '' quote'

StringLit "string with a ' quote"

'1'

StringLit "1"

interval '3' day

IntervalLit{ilSign = Nothing, ilLiteral = "3",
            ilFrom = Itf "day" Nothing, ilTo = Nothing}

interval '3' day (3)

IntervalLit{ilSign = Nothing, ilLiteral = "3",
            ilFrom = Itf "day" (Just (3, Nothing)), ilTo = Nothing}

interval '3 weeks'

TypedLit (TypeName [Name "interval"]) "3 weeks"

iden1

Iden [Name "iden1"]

"quoted identifier"

Iden [QName "quoted identifier"]

*

Star

?

Parameter

t.a

Iden [Name "t", Name "a"]

t.*

BinOp (Iden [Name "t"]) [Name "."] Star

a.b.c

Iden [Name "a", Name "b", Name "c"]

ROW(t.*,42)

App [Name "ROW"]
  [BinOp (Iden [Name "t"]) [Name "."] Star, NumLit "42"]

f()

App [Name "f"] []

f(a)

App [Name "f"] [Iden [Name "a"]]

f(a,b)

App [Name "f"] [Iden [Name "a"], Iden [Name "b"]]

case a when 1 then 2 end

Case{caseTest = Just (Iden [Name "a"]),
     caseWhens = [([NumLit "1"], NumLit "2")], caseElse = Nothing}

case a when 1 then 2 when 3 then 4 end

Case{caseTest = Just (Iden [Name "a"]),
     caseWhens =
       [([NumLit "1"], NumLit "2"), ([NumLit "3"], NumLit "4")],
     caseElse = Nothing}

case a when 1 then 2 when 3 then 4 else 5 end

Case{caseTest = Just (Iden [Name "a"]),
     caseWhens =
       [([NumLit "1"], NumLit "2"), ([NumLit "3"], NumLit "4")],
     caseElse = Just (NumLit "5")}

case when a=1 then 2 when a=3 then 4 else 5 end

Case{caseTest = Nothing,
     caseWhens =
       [([BinOp (Iden [Name "a"]) [Name "="] (NumLit "1")], NumLit "2"),
        ([BinOp (Iden [Name "a"]) [Name "="] (NumLit "3")], NumLit "4")],
     caseElse = Just (NumLit "5")}

case a when 1,2 then 10 when 3,4 then 20 end

Case{caseTest = Just (Iden [Name "a"]),
     caseWhens =
       [([NumLit "1", NumLit "2"], NumLit "10"),
        ([NumLit "3", NumLit "4"], NumLit "20")],
     caseElse = Nothing}

a + b

BinOp (Iden [Name "a"]) [Name "+"] (Iden [Name "b"])

a + b * c

BinOp (Iden [Name "a"]) [Name "+"]
  (BinOp (Iden [Name "b"]) [Name "*"] (Iden [Name "c"]))

a * b + c

BinOp (BinOp (Iden [Name "a"]) [Name "*"] (Iden [Name "b"]))
  [Name "+"]
  (Iden [Name "c"])

not a

PrefixOp [Name "not"] (Iden [Name "a"])

not not a

PrefixOp [Name "not"] (PrefixOp [Name "not"] (Iden [Name "a"]))

+a

PrefixOp [Name "+"] (Iden [Name "a"])

-a

PrefixOp [Name "-"] (Iden [Name "a"])

cast('1' as int)

Cast (StringLit "1") (TypeName [Name "int"])

int '3'

TypedLit (TypeName [Name "int"]) "3"

cast('1' as double precision)

Cast (StringLit "1") (TypeName [Name "double precision"])

cast('1' as float(8))

Cast (StringLit "1") (PrecTypeName [Name "float"] 8)

cast('1' as decimal(15,2))

Cast (StringLit "1") (PrecScaleTypeName [Name "decimal"] 15 2)

double precision '3'

TypedLit (TypeName [Name "double precision"]) "3"

a in (1,2,3)

In True (Iden [Name "a"])
  (InList [NumLit "1", NumLit "2", NumLit "3"])

a is null

PostfixOp [Name "is null"] (Iden [Name "a"])

a is not null

PostfixOp [Name "is not null"] (Iden [Name "a"])

a is true

PostfixOp [Name "is true"] (Iden [Name "a"])

a is not true

PostfixOp [Name "is not true"] (Iden [Name "a"])

a is false

PostfixOp [Name "is false"] (Iden [Name "a"])

a is not false

PostfixOp [Name "is not false"] (Iden [Name "a"])

a is unknown

PostfixOp [Name "is unknown"] (Iden [Name "a"])

a is not unknown

PostfixOp [Name "is not unknown"] (Iden [Name "a"])

a is distinct from b

BinOp (Iden [Name "a"]) [Name "is distinct from"] (Iden [Name "b"])

a is not distinct from b

BinOp (Iden [Name "a"]) [Name "is not distinct from"]
  (Iden [Name "b"])

a like b

BinOp (Iden [Name "a"]) [Name "like"] (Iden [Name "b"])

a not like b

BinOp (Iden [Name "a"]) [Name "not like"] (Iden [Name "b"])

a is similar to b

BinOp (Iden [Name "a"]) [Name "is similar to"] (Iden [Name "b"])

a is not similar to b

BinOp (Iden [Name "a"]) [Name "is not similar to"]
  (Iden [Name "b"])

a overlaps b

BinOp (Iden [Name "a"]) [Name "overlaps"] (Iden [Name "b"])

a between b and c

SpecialOp [Name "between"]
  [Iden [Name "a"], Iden [Name "b"], Iden [Name "c"]]

a not between b and c

SpecialOp [Name "not between"]
  [Iden [Name "a"], Iden [Name "b"], Iden [Name "c"]]

(1,2)

SpecialOp [Name "rowctor"] [NumLit "1", NumLit "2"]

extract(day from t)

SpecialOpK [Name "extract"] (Just (Iden [Name "day"]))
  [("from", Iden [Name "t"])]

substring(x from 1 for 2)

SpecialOpK [Name "substring"] (Just (Iden [Name "x"]))
  [("from", NumLit "1"), ("for", NumLit "2")]

substring(x from 1)

SpecialOpK [Name "substring"] (Just (Iden [Name "x"]))
  [("from", NumLit "1")]

substring(x for 2)

SpecialOpK [Name "substring"] (Just (Iden [Name "x"]))
  [("for", NumLit "2")]

substring(x from 1 for 2 collate C)

SpecialOpK [Name "substring"] (Just (Iden [Name "x"]))
  [("from", NumLit "1"), ("for", Collate (NumLit "2") [Name "C"])]

POSITION( string1 IN string2 )

SpecialOpK [Name "position"] (Just (Iden [Name "string1"]))
  [("in", Iden [Name "string2"])]

CONVERT(char_value USING conversion_char_name)

SpecialOpK [Name "convert"] (Just (Iden [Name "char_value"]))
  [("using", Iden [Name "conversion_char_name"])]

TRANSLATE(char_value USING translation_name)

SpecialOpK [Name "translate"] (Just (Iden [Name "char_value"]))
  [("using", Iden [Name "translation_name"])]

OVERLAY(string PLACING embedded_string FROM start)

SpecialOpK [Name "overlay"] (Just (Iden [Name "string"]))
  [("placing", Iden [Name "embedded_string"]),
   ("from", Iden [Name "start"])]

OVERLAY(string PLACING embedded_string FROM start FOR length)

SpecialOpK [Name "overlay"] (Just (Iden [Name "string"]))
  [("placing", Iden [Name "embedded_string"]),
   ("from", Iden [Name "start"]), ("for", Iden [Name "length"])]

trim(from target_string)

SpecialOpK [Name "trim"] Nothing
  [("both", StringLit " "), ("from", Iden [Name "target_string"])]

trim(leading from target_string)

SpecialOpK [Name "trim"] Nothing
  [("leading", StringLit " "), ("from", Iden [Name "target_string"])]

trim(trailing from target_string)

SpecialOpK [Name "trim"] Nothing
  [("trailing", StringLit " "),
   ("from", Iden [Name "target_string"])]

trim(both from target_string)

SpecialOpK [Name "trim"] Nothing
  [("both", StringLit " "), ("from", Iden [Name "target_string"])]

trim(leading 'x' from target_string)

SpecialOpK [Name "trim"] Nothing
  [("leading", StringLit "x"), ("from", Iden [Name "target_string"])]

trim(trailing 'y' from target_string)

SpecialOpK [Name "trim"] Nothing
  [("trailing", StringLit "y"),
   ("from", Iden [Name "target_string"])]

trim(both 'z' from target_string collate C)

SpecialOpK [Name "trim"] Nothing
  [("both", StringLit "z"),
   ("from", Collate (Iden [Name "target_string"]) [Name "C"])]

trim(leading from target_string)

SpecialOpK [Name "trim"] Nothing
  [("leading", StringLit " "), ("from", Iden [Name "target_string"])]

(a)

Parens (Iden [Name "a"])

(a + b)

Parens (BinOp (Iden [Name "a"]) [Name "+"] (Iden [Name "b"]))

exists (select a from t)

SubQueryExpr SqExists
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Iden [Name "a"], Nothing)],
          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

(select a from t)

SubQueryExpr SqSq
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Iden [Name "a"], Nothing)],
          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

a in (select a from t)

In True (Iden [Name "a"])
  (InQueryExpr
     (Select{qeSetQuantifier = SQDefault,
             qeSelectList = [(Iden [Name "a"], Nothing)],
             qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
             qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
             qeFetchFirst = Nothing}))

a not in (select a from t)

In False (Iden [Name "a"])
  (InQueryExpr
     (Select{qeSetQuantifier = SQDefault,
             qeSelectList = [(Iden [Name "a"], Nothing)],
             qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
             qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
             qeFetchFirst = Nothing}))

a > all (select a from t)

QuantifiedComparison (Iden [Name "a"]) [Name ">"] CPAll
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Iden [Name "a"], Nothing)],
          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

a = some (select a from t)

QuantifiedComparison (Iden [Name "a"]) [Name "="] CPSome
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Iden [Name "a"], Nothing)],
          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

a <= any (select a from t)

QuantifiedComparison (Iden [Name "a"]) [Name "<="] CPAny
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Iden [Name "a"], Nothing)],
          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

count(*)

App [Name "count"] [Star]

sum(a order by a)

AggregateApp{aggName = [Name "sum"], aggDistinct = SQDefault,
             aggArgs = [Iden [Name "a"]],
             aggOrderBy =
               [SortSpec (Iden [Name "a"]) DirDefault NullsOrderDefault],
             aggFilter = Nothing}

sum(all a)

AggregateApp{aggName = [Name "sum"], aggDistinct = All,
             aggArgs = [Iden [Name "a"]], aggOrderBy = [], aggFilter = Nothing}

count(distinct a)

AggregateApp{aggName = [Name "count"], aggDistinct = Distinct,
             aggArgs = [Iden [Name "a"]], aggOrderBy = [], aggFilter = Nothing}

max(a) over ()

WindowApp{wnName = [Name "max"], wnArgs = [Iden [Name "a"]],
          wnPartition = [], wnOrderBy = [], wnFrame = Nothing}

count(*) over ()

WindowApp{wnName = [Name "count"], wnArgs = [Star],
          wnPartition = [], wnOrderBy = [], wnFrame = Nothing}

max(a) over (partition by b)

WindowApp{wnName = [Name "max"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]], wnOrderBy = [], wnFrame = Nothing}

max(a) over (partition by b,c)

WindowApp{wnName = [Name "max"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"], Iden [Name "c"]], wnOrderBy = [],
          wnFrame = Nothing}

sum(a) over (order by b)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [],
          wnOrderBy =
            [SortSpec (Iden [Name "b"]) DirDefault NullsOrderDefault],
          wnFrame = Nothing}

sum(a) over (order by b desc,c)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [],
          wnOrderBy =
            [SortSpec (Iden [Name "b"]) Desc NullsOrderDefault,
             SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Nothing}

sum(a) over (partition by b order by c)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Nothing}

sum(a) over (partition by b order by c range unbounded preceding)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Just (FrameFrom FrameRange UnboundedPreceding)}

sum(a) over (partition by b order by c range 5 preceding)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Just (FrameFrom FrameRange (Preceding (NumLit "5")))}

sum(a) over (partition by b order by c range current row)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Just (FrameFrom FrameRange Current)}

sum(a) over (partition by b order by c rows 5 following)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Just (FrameFrom FrameRows (Following (NumLit "5")))}

sum(a) over (partition by b order by c range unbounded following)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame = Just (FrameFrom FrameRange UnboundedFollowing)}

sum(a) over (partition by b order by c 
range between 5 preceding and 5 following)

WindowApp{wnName = [Name "sum"], wnArgs = [Iden [Name "a"]],
          wnPartition = [Iden [Name "b"]],
          wnOrderBy =
            [SortSpec (Iden [Name "c"]) DirDefault NullsOrderDefault],
          wnFrame =
            Just
              (FrameBetween FrameRange (Preceding (NumLit "5"))
                 (Following (NumLit "5")))}

select a from t

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select all a from t

Select{qeSetQuantifier = All,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select distinct a from t

Select{qeSetQuantifier = Distinct,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select 1

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)], qeFrom = [],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a,b

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(Iden [Name "a"], Nothing), (Iden [Name "b"], Nothing)],
       qeFrom = [], qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select 1+2,3+4

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(BinOp (NumLit "1") [Name "+"] (NumLit "2"), Nothing),
          (BinOp (NumLit "3") [Name "+"] (NumLit "4"), Nothing)],
       qeFrom = [], qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a as a, /*comment*/ b as b

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(Iden [Name "a"], Just (Name "a")),
          (Iden [Name "b"], Just (Name "b"))],
       qeFrom = [], qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a a, b b

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(Iden [Name "a"], Just (Name "a")),
          (Iden [Name "b"], Just (Name "b"))],
       qeFrom = [], qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a + b * c

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(BinOp (Iden [Name "a"]) [Name "+"]
             (BinOp (Iden [Name "b"]) [Name "*"] (Iden [Name "c"])),
           Nothing)],
       qeFrom = [], qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t where a = 5

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]],
       qeWhere = Just (BinOp (Iden [Name "a"]) [Name "="] (NumLit "5")),
       qeGroupBy = [], qeHaving = Nothing, qeOrderBy = [],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a,sum(b) from t group by a having sum(b) > 5

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(Iden [Name "a"], Nothing),
          (App [Name "sum"] [Iden [Name "b"]], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing,
       qeGroupBy = [SimpleGroup (Iden [Name "a"])],
       qeHaving =
         Just
           (BinOp (App [Name "sum"] [Iden [Name "b"]]) [Name ">"]
              (NumLit "5")),
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t order by a

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing,
       qeOrderBy =
         [SortSpec (Iden [Name "a"]) DirDefault NullsOrderDefault],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t order by a, b

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing,
       qeOrderBy =
         [SortSpec (Iden [Name "a"]) DirDefault NullsOrderDefault,
          SortSpec (Iden [Name "b"]) DirDefault NullsOrderDefault],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t order by a asc

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing,
       qeOrderBy = [SortSpec (Iden [Name "a"]) Asc NullsOrderDefault],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t order by a desc, b desc

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing,
       qeOrderBy =
         [SortSpec (Iden [Name "a"]) Desc NullsOrderDefault,
          SortSpec (Iden [Name "b"]) Desc NullsOrderDefault],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t order by a desc nulls first, b desc nulls last

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing,
       qeOrderBy =
         [SortSpec (Iden [Name "a"]) Desc NullsFirst,
          SortSpec (Iden [Name "b"]) Desc NullsLast],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t offset 5 rows fetch next 10 rows only

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Just (NumLit "5"),
       qeFetchFirst = Just (NumLit "10")}

select a from t offset 5 rows;

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Just (NumLit "5"),
       qeFetchFirst = Nothing}

select a from t fetch next 10 row only;

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Just (NumLit "10")}

select a from t offset 5 row fetch first 10 row only

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Just (NumLit "5"),
       qeFetchFirst = Just (NumLit "10")}

select a from t union select b from u

CombineQueryExpr{qe0 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "a"], Nothing)],
                          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing},
                 qeCombOp = Union, qeSetQuantifier = SQDefault,
                 qeCorresponding = Respectively,
                 qe1 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "b"], Nothing)],
                          qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing}}

select a from t intersect select b from u

CombineQueryExpr{qe0 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "a"], Nothing)],
                          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing},
                 qeCombOp = Intersect, qeSetQuantifier = SQDefault,
                 qeCorresponding = Respectively,
                 qe1 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "b"], Nothing)],
                          qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing}}

select a from t except all select b from u

CombineQueryExpr{qe0 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "a"], Nothing)],
                          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing},
                 qeCombOp = Except, qeSetQuantifier = All,
                 qeCorresponding = Respectively,
                 qe1 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "b"], Nothing)],
                          qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing}}

select a from t union distinct corresponding select b from u

CombineQueryExpr{qe0 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "a"], Nothing)],
                          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing},
                 qeCombOp = Union, qeSetQuantifier = Distinct,
                 qeCorresponding = Corresponding,
                 qe1 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "b"], Nothing)],
                          qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing}}

select a from t union select a from t union select a from t

CombineQueryExpr{qe0 =
                   Select{qeSetQuantifier = SQDefault,
                          qeSelectList = [(Iden [Name "a"], Nothing)],
                          qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                          qeFetchFirst = Nothing},
                 qeCombOp = Union, qeSetQuantifier = SQDefault,
                 qeCorresponding = Respectively,
                 qe1 =
                   CombineQueryExpr{qe0 =
                                      Select{qeSetQuantifier = SQDefault,
                                             qeSelectList = [(Iden [Name "a"], Nothing)],
                                             qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing,
                                             qeGroupBy = [], qeHaving = Nothing, qeOrderBy = [],
                                             qeOffset = Nothing, qeFetchFirst = Nothing},
                                    qeCombOp = Union, qeSetQuantifier = SQDefault,
                                    qeCorresponding = Respectively,
                                    qe1 =
                                      Select{qeSetQuantifier = SQDefault,
                                             qeSelectList = [(Iden [Name "a"], Nothing)],
                                             qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing,
                                             qeGroupBy = [], qeHaving = Nothing, qeOrderBy = [],
                                             qeOffset = Nothing, qeFetchFirst = Nothing}}}

with u as (select a from t) select a from u

With{qeWithRecursive = False,
     qeViews =
       [(Alias (Name "u") Nothing,
         Select{qeSetQuantifier = SQDefault,
                qeSelectList = [(Iden [Name "a"], Nothing)],
                qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                qeFetchFirst = Nothing})],
     qeQueryExpression =
       Select{qeSetQuantifier = SQDefault,
              qeSelectList = [(Iden [Name "a"], Nothing)],
              qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
              qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
              qeFetchFirst = Nothing}}

with u(b) as (select a from t) select a from u

With{qeWithRecursive = False,
     qeViews =
       [(Alias (Name "u") (Just [Name "b"]),
         Select{qeSetQuantifier = SQDefault,
                qeSelectList = [(Iden [Name "a"], Nothing)],
                qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                qeFetchFirst = Nothing})],
     qeQueryExpression =
       Select{qeSetQuantifier = SQDefault,
              qeSelectList = [(Iden [Name "a"], Nothing)],
              qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
              qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
              qeFetchFirst = Nothing}}

with x as (select a from t),
     u as (select a from x)
select a from u

With{qeWithRecursive = False,
     qeViews =
       [(Alias (Name "x") Nothing,
         Select{qeSetQuantifier = SQDefault,
                qeSelectList = [(Iden [Name "a"], Nothing)],
                qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                qeFetchFirst = Nothing}),
        (Alias (Name "u") Nothing,
         Select{qeSetQuantifier = SQDefault,
                qeSelectList = [(Iden [Name "a"], Nothing)],
                qeFrom = [TRSimple [Name "x"]], qeWhere = Nothing, qeGroupBy = [],
                qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                qeFetchFirst = Nothing})],
     qeQueryExpression =
       Select{qeSetQuantifier = SQDefault,
              qeSelectList = [(Iden [Name "a"], Nothing)],
              qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
              qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
              qeFetchFirst = Nothing}}

with recursive u as (select a from t) select a from u

With{qeWithRecursive = True,
     qeViews =
       [(Alias (Name "u") Nothing,
         Select{qeSetQuantifier = SQDefault,
                qeSelectList = [(Iden [Name "a"], Nothing)],
                qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                qeFetchFirst = Nothing})],
     qeQueryExpression =
       Select{qeSetQuantifier = SQDefault,
              qeSelectList = [(Iden [Name "a"], Nothing)],
              qeFrom = [TRSimple [Name "u"]], qeWhere = Nothing, qeGroupBy = [],
              qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
              qeFetchFirst = Nothing}}

values (1,2),(3,4)

Values [[NumLit "1", NumLit "2"], [NumLit "3", NumLit "4"]]

table tbl

Table [Name "tbl"]

select 1

[Select{qeSetQuantifier = SQDefault,
        qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
        qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
        qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}]

select 1;

[Select{qeSetQuantifier = SQDefault,
        qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
        qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
        qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}]

select 1;select 1

[Select{qeSetQuantifier = SQDefault,
        qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
        qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
        qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing},
 Select{qeSetQuantifier = SQDefault,
        qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
        qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
        qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}]

 select 1;select 1; 

[Select{qeSetQuantifier = SQDefault,
        qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
        qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
        qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing},
 Select{qeSetQuantifier = SQDefault,
        qeSelectList = [(NumLit "1", Nothing)], qeFrom = [],
        qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
        qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}]

select a from t

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select a from f(a)

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRFunction [Name "f"] [Iden [Name "a"]]],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t,u

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "t"], TRSimple [Name "u"]],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from s.t

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "s", Name "t"]], qeWhere = Nothing,
       qeGroupBy = [], qeHaving = Nothing, qeOrderBy = [],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from lateral a

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRLateral (TRSimple [Name "a"])], qeWhere = Nothing,
       qeGroupBy = [], qeHaving = Nothing, qeOrderBy = [],
       qeOffset = Nothing, qeFetchFirst = Nothing}

select a from lateral a,b

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRLateral (TRSimple [Name "a"]), TRSimple [Name "b"]],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from a, lateral b

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom = [TRSimple [Name "a"], TRLateral (TRSimple [Name "b"])],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from a natural join lateral b

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "a"]) True JInner
            (TRLateral (TRSimple [Name "b"]))
            Nothing],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from lateral a natural join lateral b

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRLateral (TRSimple [Name "a"])) True JInner
            (TRLateral (TRSimple [Name "b"]))
            Nothing],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t inner join u on expr

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JInner (TRSimple [Name "u"])
            (Just (JoinOn (Iden [Name "expr"])))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t join u on expr

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JInner (TRSimple [Name "u"])
            (Just (JoinOn (Iden [Name "expr"])))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t left join u on expr

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JLeft (TRSimple [Name "u"])
            (Just (JoinOn (Iden [Name "expr"])))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t right join u on expr

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JRight (TRSimple [Name "u"])
            (Just (JoinOn (Iden [Name "expr"])))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t full join u on expr

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JFull (TRSimple [Name "u"])
            (Just (JoinOn (Iden [Name "expr"])))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t cross join u

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JCross (TRSimple [Name "u"])
            Nothing],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t natural inner join u

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) True JInner (TRSimple [Name "u"])
            Nothing],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t inner join u using(a,b)

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin (TRSimple [Name "t"]) False JInner (TRSimple [Name "u"])
            (Just (JoinUsing [Name "a", Name "b"]))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from (select a from t)

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRQueryExpr
            (Select{qeSetQuantifier = SQDefault,
                    qeSelectList = [(Iden [Name "a"], Nothing)],
                    qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing, qeGroupBy = [],
                    qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
                    qeFetchFirst = Nothing})],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t as u

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRAlias (TRSimple [Name "t"]) (Alias (Name "u") Nothing)],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t u

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRAlias (TRSimple [Name "t"]) (Alias (Name "u") Nothing)],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t u(b)

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRAlias (TRSimple [Name "t"])
            (Alias (Name "u") (Just [Name "b"]))],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from (t cross join u) as u

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRAlias
            (TRParens
               (TRJoin (TRSimple [Name "t"]) False JCross (TRSimple [Name "u"])
                  Nothing))
            (Alias (Name "u") Nothing)],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a from t cross join u cross join v

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Iden [Name "a"], Nothing)],
       qeFrom =
         [TRJoin
            (TRJoin (TRSimple [Name "t"]) False JCross (TRSimple [Name "u"])
               Nothing)
            False
            JCross
            (TRSimple [Name "v"])
            Nothing],
       qeWhere = Nothing, qeGroupBy = [], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a,sum(b) from t group by a

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(Iden [Name "a"], Nothing),
          (App [Name "sum"] [Iden [Name "b"]], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing,
       qeGroupBy = [SimpleGroup (Iden [Name "a"])], qeHaving = Nothing,
       qeOrderBy = [], qeOffset = Nothing, qeFetchFirst = Nothing}

select a,b,sum(c) from t group by a,b

Select{qeSetQuantifier = SQDefault,
       qeSelectList =
         [(Iden [Name "a"], Nothing), (Iden [Name "b"], Nothing),
          (App [Name "sum"] [Iden [Name "c"]], Nothing)],
       qeFrom = [TRSimple [Name "t"]], qeWhere = Nothing,
       qeGroupBy =
         [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select * from t group by ()

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
       qeWhere = Nothing, qeGroupBy = [GroupingParens []],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select * from t group by grouping sets ((), (a))

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
       qeWhere = Nothing,
       qeGroupBy =
         [GroupingSets
            [GroupingParens [],
             GroupingParens [SimpleGroup (Iden [Name "a"])]]],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select * from t group by cube(a,b)

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
       qeWhere = Nothing,
       qeGroupBy =
         [Cube
            [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])]],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select * from t group by rollup(a,b)

Select{qeSetQuantifier = SQDefault,
       qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
       qeWhere = Nothing,
       qeGroupBy =
         [Rollup
            [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])]],
       qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
       qeFetchFirst = Nothing}

select * from t GROUP BY a

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing, qeGroupBy = [SimpleGroup (Iden [Name "a"])],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a))

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets [GroupingParens [SimpleGroup (Iden [Name "a"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY a,b,c

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
             SimpleGroup (Iden [Name "c"])],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c))

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(a,b)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b),
(a),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(b,a)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "a"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((b,a),
(b),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "a"])],
                GroupingParens [SimpleGroup (Iden [Name "b"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY CUBE(a,b,c)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Cube
               [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                SimpleGroup (Iden [Name "c"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c),
(a,b),
(a,c),
(b,c),
(a),
(b),
(c),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])],
                GroupingParens [SimpleGroup (Iden [Name "b"])],
                GroupingParens [SimpleGroup (Iden [Name "c"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(Province, County, City)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (Iden [Name "Province"]),
                SimpleGroup (Iden [Name "County"]),
                SimpleGroup (Iden [Name "City"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(Province, (County, City))

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (Iden [Name "Province"]),
                GroupingParens
                  [SimpleGroup (Iden [Name "County"]),
                   SimpleGroup (Iden [Name "City"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(Province, (County, City))

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (Iden [Name "Province"]),
                GroupingParens
                  [SimpleGroup (Iden [Name "County"]),
                   SimpleGroup (Iden [Name "City"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((Province, County, City),
(Province),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "Province"]),
                   SimpleGroup (Iden [Name "County"]),
                   SimpleGroup (Iden [Name "City"])],
                GroupingParens [SimpleGroup (Iden [Name "Province"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((Province, County, City),
(Province, County),
(Province),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "Province"]),
                   SimpleGroup (Iden [Name "County"]),
                   SimpleGroup (Iden [Name "City"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "Province"]),
                   SimpleGroup (Iden [Name "County"])],
                GroupingParens [SimpleGroup (Iden [Name "Province"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY a, ROLLUP(b,c)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [SimpleGroup (Iden [Name "a"]),
             Rollup
               [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c),
(a,b),
(a) )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY a, b, ROLLUP(c,d)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
             Rollup
               [SimpleGroup (Iden [Name "c"]), SimpleGroup (Iden [Name "d"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c,d),
(a,b,c),
(a,b) )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"]), SimpleGroup (Iden [Name "d"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(a), ROLLUP(b,c)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup [SimpleGroup (Iden [Name "a"])],
             Rollup
               [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c),
(a,b),
(a),
(b,c),
(b),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens [SimpleGroup (Iden [Name "b"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP(a), CUBE(b,c)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup [SimpleGroup (Iden [Name "a"])],
             Cube
               [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c),
(a,b),
(a,c),
(a),
(b,c),
(b),
(c),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens [SimpleGroup (Iden [Name "b"])],
                GroupingParens [SimpleGroup (Iden [Name "c"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY CUBE(a,b), ROLLUP(c,d)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Cube
               [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
             Rollup
               [SimpleGroup (Iden [Name "c"]), SimpleGroup (Iden [Name "d"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b,c,d),
(a,b,c),
(a,b),
(a,c,d),
(a,c),
(a),
(b,c,d),
(b,c),
(b),
(c,d),
(c),
() )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"]), SimpleGroup (Iden [Name "d"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"]),
                   SimpleGroup (Iden [Name "c"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "c"]),
                   SimpleGroup (Iden [Name "d"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"]),
                   SimpleGroup (Iden [Name "d"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "b"]), SimpleGroup (Iden [Name "c"])],
                GroupingParens [SimpleGroup (Iden [Name "b"])],
                GroupingParens
                  [SimpleGroup (Iden [Name "c"]), SimpleGroup (Iden [Name "d"])],
                GroupingParens [SimpleGroup (Iden [Name "c"])],
                GroupingParens []]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY a, ROLLUP(a,b)

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [SimpleGroup (Iden [Name "a"]),
             Rollup
               [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY GROUPING SETS((a,b),
(a) )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "a"]), SimpleGroup (Iden [Name "b"])],
                GroupingParens [SimpleGroup (Iden [Name "a"])]]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY Region,
ROLLUP(Sales_Person, WEEK(Sales_Date)),
CUBE(YEAR(Sales_Date), MONTH (Sales_Date))

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [SimpleGroup (Iden [Name "Region"]),
             Rollup
               [SimpleGroup (Iden [Name "Sales_Person"]),
                SimpleGroup (App [Name "WEEK"] [Iden [Name "Sales_Date"]])],
             Cube
               [SimpleGroup (App [Name "YEAR"] [Iden [Name "Sales_Date"]]),
                SimpleGroup (App [Name "MONTH"] [Iden [Name "Sales_Date"]])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

select * from t GROUP BY ROLLUP (Region, Sales_Person, WEEK(Sales_Date),
YEAR(Sales_Date), MONTH(Sales_Date) )

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList = [(Star, Nothing)], qeFrom = [TRSimple [Name "t"]],
          qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (Iden [Name "Region"]),
                SimpleGroup (Iden [Name "Sales_Person"]),
                SimpleGroup (App [Name "WEEK"] [Iden [Name "Sales_Date"]]),
                SimpleGroup (App [Name "YEAR"] [Iden [Name "Sales_Date"]]),
                SimpleGroup (App [Name "MONTH"] [Iden [Name "Sales_Date"]])]],
          qeHaving = Nothing, qeOrderBy = [], qeOffset = Nothing,
          qeFetchFirst = Nothing})

SELECT WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
SALES_PERSON, SUM(SALES) AS UNITS_SOLD
FROM SALES
WHERE WEEK(SALES_DATE) = 13
GROUP BY WEEK(SALES_DATE), DAYOFWEEK(SALES_DATE), SALES_PERSON
ORDER BY WEEK, DAY_WEEK, SALES_PERSON

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "WEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (Iden [Name "SALES_PERSON"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]],
          qeWhere =
            Just
              (BinOp (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]) [Name "="]
                 (NumLit "13")),
          qeGroupBy =
            [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
             SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]]),
             SimpleGroup (Iden [Name "SALES_PERSON"])],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "SALES_PERSON"]) DirDefault
               NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
SALES_PERSON, SUM(SALES) AS UNITS_SOLD
FROM SALES
WHERE WEEK(SALES_DATE) = 13
GROUP BY GROUPING SETS ( (WEEK(SALES_DATE), SALES_PERSON),
(DAYOFWEEK(SALES_DATE), SALES_PERSON))
ORDER BY WEEK, DAY_WEEK, SALES_PERSON

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "WEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (Iden [Name "SALES_PERSON"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]],
          qeWhere =
            Just
              (BinOp (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]) [Name "="]
                 (NumLit "13")),
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
                   SimpleGroup (Iden [Name "SALES_PERSON"])],
                GroupingParens
                  [SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]]),
                   SimpleGroup (Iden [Name "SALES_PERSON"])]]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "SALES_PERSON"]) DirDefault
               NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
SALES_PERSON, SUM(SALES) AS UNITS_SOLD
FROM SALES
WHERE WEEK(SALES_DATE) = 13
GROUP BY ROLLUP ( WEEK(SALES_DATE), DAYOFWEEK(SALES_DATE), SALES_PERSON )
ORDER BY WEEK, DAY_WEEK, SALES_PERSON

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "WEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (Iden [Name "SALES_PERSON"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]],
          qeWhere =
            Just
              (BinOp (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]) [Name "="]
                 (NumLit "13")),
          qeGroupBy =
            [Rollup
               [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
                SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]]),
                SimpleGroup (Iden [Name "SALES_PERSON"])]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "SALES_PERSON"]) DirDefault
               NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
SALES_PERSON, SUM(SALES) AS UNITS_SOLD
FROM SALES
WHERE WEEK(SALES_DATE) = 13
GROUP BY CUBE ( WEEK(SALES_DATE), DAYOFWEEK(SALES_DATE), SALES_PERSON )
ORDER BY WEEK, DAY_WEEK, SALES_PERSON

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "WEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (Iden [Name "SALES_PERSON"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]],
          qeWhere =
            Just
              (BinOp (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]) [Name "="]
                 (NumLit "13")),
          qeGroupBy =
            [Cube
               [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
                SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]]),
                SimpleGroup (Iden [Name "SALES_PERSON"])]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "SALES_PERSON"]) DirDefault
               NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT SALES_PERSON,
MONTH(SALES_DATE) AS MONTH,
SUM(SALES) AS UNITS_SOLD
FROM SALES
GROUP BY GROUPING SETS ( (SALES_PERSON, MONTH(SALES_DATE)),
()
)
ORDER BY SALES_PERSON, MONTH

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(Iden [Name "SALES_PERSON"], Nothing),
             (App [Name "MONTH"] [Iden [Name "SALES_DATE"]],
              Just (Name "MONTH")),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]], qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "SALES_PERSON"]),
                   SimpleGroup (App [Name "MONTH"] [Iden [Name "SALES_DATE"]])],
                GroupingParens []]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "SALES_PERSON"]) DirDefault
               NullsOrderDefault,
             SortSpec (Iden [Name "MONTH"]) DirDefault NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
SUM(SALES) AS UNITS_SOLD
FROM SALES
GROUP BY ROLLUP ( WEEK(SALES_DATE), DAYOFWEEK(SALES_DATE) )
ORDER BY WEEK, DAY_WEEK

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "WEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]], qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
                SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]])]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT MONTH(SALES_DATE) AS MONTH,
REGION,
SUM(SALES) AS UNITS_SOLD
FROM SALES
GROUP BY ROLLUP ( MONTH(SALES_DATE), REGION )
ORDER BY MONTH, REGION

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "MONTH"] [Iden [Name "SALES_DATE"]],
              Just (Name "MONTH")),
             (Iden [Name "REGION"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]], qeWhere = Nothing,
          qeGroupBy =
            [Rollup
               [SimpleGroup (App [Name "MONTH"] [Iden [Name "SALES_DATE"]]),
                SimpleGroup (Iden [Name "REGION"])]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "MONTH"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "REGION"]) DirDefault NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
MONTH(SALES_DATE) AS MONTH,
REGION,
SUM(SALES) AS UNITS_SOLD
FROM SALES
GROUP BY GROUPING SETS ( ROLLUP( WEEK(SALES_DATE), DAYOFWEEK(SALES_DATE) ),
ROLLUP( MONTH(SALES_DATE), REGION ) )
ORDER BY WEEK, DAY_WEEK, MONTH, REGION

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(App [Name "WEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (App [Name "MONTH"] [Iden [Name "SALES_DATE"]],
              Just (Name "MONTH")),
             (Iden [Name "REGION"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom = [TRSimple [Name "SALES"]], qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [Rollup
                  [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
                   SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]])],
                Rollup
                  [SimpleGroup (App [Name "MONTH"] [Iden [Name "SALES_DATE"]]),
                   SimpleGroup (Iden [Name "REGION"])]]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "MONTH"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "REGION"]) DirDefault NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})

SELECT R1, R2,
WEEK(SALES_DATE) AS WEEK,
DAYOFWEEK(SALES_DATE) AS DAY_WEEK,
MONTH(SALES_DATE) AS MONTH,
REGION, SUM(SALES) AS UNITS_SOLD
FROM SALES,(VALUES('GROUP 1','GROUP 2')) AS X(R1,R2)
GROUP BY GROUPING SETS ((R1, ROLLUP(WEEK(SALES_DATE),
DAYOFWEEK(SALES_DATE))),
(R2,ROLLUP( MONTH(SALES_DATE), REGION ) ))
ORDER BY WEEK, DAY_WEEK, MONTH, REGION

Right
  (Select{qeSetQuantifier = SQDefault,
          qeSelectList =
            [(Iden [Name "R1"], Nothing), (Iden [Name "R2"], Nothing),
             (App [Name "WEEK"] [Iden [Name "SALES_DATE"]], Just (Name "WEEK")),
             (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]],
              Just (Name "DAY_WEEK")),
             (App [Name "MONTH"] [Iden [Name "SALES_DATE"]],
              Just (Name "MONTH")),
             (Iden [Name "REGION"], Nothing),
             (App [Name "SUM"] [Iden [Name "SALES"]],
              Just (Name "UNITS_SOLD"))],
          qeFrom =
            [TRSimple [Name "SALES"],
             TRAlias
               (TRQueryExpr (Values [[StringLit "GROUP 1", StringLit "GROUP 2"]]))
               (Alias (Name "X") (Just [Name "R1", Name "R2"]))],
          qeWhere = Nothing,
          qeGroupBy =
            [GroupingSets
               [GroupingParens
                  [SimpleGroup (Iden [Name "R1"]),
                   Rollup
                     [SimpleGroup (App [Name "WEEK"] [Iden [Name "SALES_DATE"]]),
                      SimpleGroup (App [Name "DAYOFWEEK"] [Iden [Name "SALES_DATE"]])]],
                GroupingParens
                  [SimpleGroup (Iden [Name "R2"]),
                   Rollup
                     [SimpleGroup (App [Name "MONTH"] [Iden [Name "SALES_DATE"]]),
                      SimpleGroup (Iden [Name "REGION"])]]]],
          qeHaving = Nothing,
          qeOrderBy =
            [SortSpec (Iden [Name "WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "DAY_WEEK"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "MONTH"]) DirDefault NullsOrderDefault,
             SortSpec (Iden [Name "REGION"]) DirDefault NullsOrderDefault],
          qeOffset = Nothing, qeFetchFirst = Nothing})