Test

renders without crashing

CurrentRelExpr

changes the expression when clicked not relation

DataContainer

displays a table with the current data

can change tables browser

can change tables mobile

RelExpr

correctly renders a complex expression

produces an error for an invalid expression

doesnt change the expression when clicked and relation

changes the expression when clicked not relation

should add (and remove) a class on hover

correctly renders a complex expression

produces an error for an invalid expression

doesnt change the expression when clicked and relation

changes the expression when clicked not relation

renders a projection

renders a Rename

renders a Rename with multiple fields

renders a Selection with single predicate

renders a Selection with multiple predicates

renders a Except

renders a Intersect

renders a Product

renders an inner Join

renders a left outer Join

renders a right outer Join

renders a Union

renders GROUP BY with aggregate only (no grouping columns)

renders GROUP BY with grouping columns and aggregate

renders GROUP BY with selected columns and aggregates

renders GROUP BY with multiple grouping columns

renders GROUP BY with multiple aggregates

renders GROUP BY with mixed select columns and aggregates

handles qualified column names

renders correctly without selectColumns prop

renders a simple label

SqlAutocomplete

parseForAutocomplete

detects table context after FROM

detects table context after JOIN

detects column context after SELECT

detects column context after WHERE

detects qualified column context

returns null context for non-relevant positions

generateSuggestions

suggests table names

suggests column names

suggests qualified column names for specific table

limits suggestions to 10 items

returns empty array for no matches

can parse the initial query

can parse modified query and fire an event

can render a table

can disable sorting

correctly renders tutorial given no cookie

cookie exists, no tutorial

constructRelationalGraph

should return the correct graph for a simple expression

should return the correct global selections for simple expression

should correctly parse multiple selections with and operator

should correctly parse multiple selections with and operator and global selections

should handle invalid selection operator types like "or"

should handle simple join expressions with selection clauses

should handle complex join expressions with selection clauses

should handle cyclic join expressions with selection clauses

should not optimize for edge case join conditions

should not optimize for multi-table join query

can evaluate a simple relation

can evaluate a projection

can evaluate a projection with dots

can evaluate a rename

can evaluate a difference

can evaluate an intersection

can evaluate a distinct union

can evaluate a union

can evaluate a default (ascending) sorting

can evaluate a descending sorting

converts a sorting on multiple column conditions

can evaluate an inner join

can project after multiple joins

can evaluate an left join

can evaluate an right join

can evaluate a cross-product

can evaluate GROUP BY with aggregate only

can evaluate GROUP BY with mixed columns and aggregates

can evaluate GROUP BY with multiple aggregates

can evaluate aggregate without GROUP BY (implicit grouping)

can evaluate GROUP BY with qualified column names

handles all aggregate functions correctly

maintains correct group separation

can evaluate HAVING clause with COUNT aggregate

can evaluate HAVING clause with AVG aggregate

can evaluate HAVING clause with complex condition using AND

can evaluate HAVING with extra aggregates not in SELECT

join order optimization

should return the correct join order for simple join queries

should return the correct join order for complex join queries

should return the correct join order for cyclic join queries

should handle disconnected graph gracefully

should handle empty graph gracefully

converts a simple SELECT *

converts a simple projection

converts a rename

converts a difference

converts an intersection

converts a distinct union

converts a union

converts a union on two tables with the same column

converts a simple cross join

converts a join with a condition

converts a left outer join with a condition

converts a right outer join with a condition

converts a pre-optimized select-join statement with a condition

converts a post-optimized select-join statement with a condition

checks if a select-join statement with a condition converts back correctly after optimization

converts a pre-optimized select-join statement with multiple conditions

converts a post-optimized select-join statement with multiple conditions

checks if a select-join statement with mutiple condition converts back correctly after optimization

converts a default (ascending) sorting

converts a descending sorting

converts a sorting on multiple column conditions

converts a selection

converts a selection with a literal on the left

converts a selection with BETWEEN

converts a basic selection with multiple 'AND's

converts a basic selection with both 'AND's in 'OR'

converts a basic selection with both 'OR's in 'AND'

converts a basic selection with both 'OR's in 'AND'

converts a selection with more than two 'AND' clauses

converts a selection with NOT

throws an error if a column is referenced in a table not joined

throws an error if no FROM clause is given

should remove quotes from string literals

should convert conditions with IN

should convert conditions with IN

converts a GROUP BY with aggregate only

converts a GROUP BY with mixed columns and aggregates

converts a GROUP BY with multiple aggregates

converts aggregate without GROUP BY (implicit grouping)

converts GROUP BY with qualified column names

supports all aggregate functions

throws error when non-aggregate column not in GROUP BY

throws error when ORDER BY column not in GROUP BY

allows ORDER BY with GROUP BY column

handles qualified vs unqualified column name matching

converts a GROUP BY with COUNT aggregate

converts a GROUP BY with STDEV aggregate

converts STDEV aggregate without GROUP BY (implicit grouping)

converts a GROUP BY with HAVING clause using aggregate function

converts a GROUP BY with HAVING clause using multiple aggregate functions

converts a GROUP BY with HAVING clause using GROUP BY column

throws error when HAVING clause references column not in GROUP BY

throws error when HAVING clause uses non-aggregate function

converts HAVING with BETWEEN predicate using aggregate

converts HAVING with OR condition using aggregates

adds projection when HAVING uses aggregates not in SELECT

converts a GROUP BY with HAVING clause using STDEV aggregate

has a valid initial state

renders an and

renders an or

renders a not