query-interpreter/q/select_test.go

package q

import (
	"fmt"
	"testing"
)

type ParsingTest struct {
	input    string
	expected Select
}

func TestParseSelectStatement(t *testing.T) {
	var testSqlStatements = []ParsingTest{
		{
			input: "SELECT * FROM  users WHERE age >= 30",
			expected: Select{
				Table:      "users",
				IsWildcard: true,
				Conditionals: []Conditional{
					{
						Key:      "age",
						Operator: ">=",
						Value:    "30",
					},
				},
			},
		},
		{
			input: "SELECT CustomerName, City FROM Customers",
			expected: Select{
				Table:      "Customers",
				IsWildcard: false,
				Columns: []Column{
					{
						Name: "CustomerName",
					},
					{
						Name: "City",
					},
				},
			},
		},
		{
			input: "SELECT DISTINCT Country FROM Nations;",
			expected: Select{
				Table: "Nations",
				Columns: []Column{
					{
						Name: "Country",
					},
				},
			},
		},
		{
			input: "SELECT * FROM Orders ORDER BY StreetNumber, CountryCode;",
			expected: Select{
				Table:      "Orders",
				IsWildcard: true,
				OrderBys: []OrderBy{
					{
						Key: "StreetNumber",
					},
					{
						Key: "CountryCode",
					},
				},
			},
		},
		{
			input: "SELECT * FROM ZipCodes ORDER BY Code ASC, StateName DESC",
			expected: Select{
				Table:      "ZipCodes",
				IsWildcard: true,
				OrderBys: []OrderBy{
					{
						Key:       "Code",
						IsDescend: false,
					},
					{
						Key:       "StateName",
						IsDescend: true,
					},
				},
			},
		},
		{
			input: "SELECT id, streetNumber, streetName, city, state FROM Addresses WHERE state = 'AL' AND zip > 9000 OR zip <= 12000 ORDER BY zip DESC, streetNumber",
			expected: Select{
				Table:      "Addresses",
				IsWildcard: false,
				Columns: []Column{
					{
						Name: "id",
					},
					{
						Name: "streetNumber",
					},
					{
						Name: "streetName",
					},
					{
						Name: "city",
					},
					{
						Name: "state",
					},
				},
				Conditionals: []Conditional{
					{
						Key:      "state",
						Operator: "=",
						Value:    "'AL'",
					},
					{
						Key:       "zip",
						Operator:  ">",
						Value:     "9000",
						Extension: "AND",
					},
					{
						Key:       "zip",
						Operator:  "<=",
						Value:     "12000",
						Extension: "OR",
					},
				},
				OrderBys: []OrderBy{
					{
						Key:       "zip",
						IsDescend: true,
					},
					{
						Key:       "streetNumber",
						IsDescend: false,
					},
				},
			},
		},
		//	{
		//		input: "SELECT ProductID, ProductName, CategoryName FROM Products INNER JOIN Categories ON Products.CategoryID = Categories.CategoryID; ",
		//		expected: Select{
		//			Table: "Products",
		//			Columns: []Column{
		//				{Name: "ProductID"},
		//				{Name: "ProductName"},
		//				{Name: "CategoryName"},
		//			},
		//			Joins: []Join{
		//				{
		//					Type: INNER,
		//					Table: Table{
		//						Name: "Categories",
		//					},
		//					Ons: []Conditional{
		//						{
		//							Key:      "Products.CategoryID",
		//							Operator: "=",
		//							Value:    "Categories.CategoryID",
		//						},
		//					},
		//				},
		//			},
		//		},
		//		},
	}

	for _, sql := range testSqlStatements {
		testName := fmt.Sprintf("%s", sql.input)
		expected := sql.expected

		t.Run(testName, func(t *testing.T) {
			answer := ParseSelectStatement(sql.input)

			if answer.Table != expected.Table {
				t.Errorf("got %s for Select.Table, expected %s", answer.Table, expected.Table)
			}
			if answer.IsWildcard != expected.IsWildcard {
				t.Errorf("got %#v for Select.IsWildcard, expected %#v", answer.IsWildcard, expected.IsWildcard)
			}
			if len(answer.Columns) != len(expected.Columns) {
				t.Errorf("got %d number of columns for Select.Columns, expected %d", len(answer.Columns), len(expected.Columns))
			} else {
				for i, expectedColumn := range expected.Columns {
					if expectedColumn.Name != answer.Columns[i].Name {
						t.Errorf("got %s for Select.Column[%d].Name, expected %s", answer.Columns[i].Name, i, expectedColumn.Name)
					}
					if expectedColumn.Alias != answer.Columns[i].Alias {
						t.Errorf("got %s for Select.Column[%ORDER].Alias, expected %s", answer.Columns[i].Alias, i, expectedColumn.Alias)
					}
					if expectedColumn.AggregateFunction != answer.Columns[i].AggregateFunction {
						t.Errorf("got %d for Select.Column[%d].AggregateFunction, expected %d", answer.Columns[i].AggregateFunction, i, expectedColumn.AggregateFunction)
					}
				}
			}

			if len(answer.Conditionals) != len(expected.Conditionals) {
				t.Errorf("got %d number of conditionals for Select.Conditionals, expected %d", len(answer.Conditionals), len(expected.Conditionals))
			} else {
				for i, expectedCondition := range expected.Conditionals {
					if expectedCondition.Key != answer.Conditionals[i].Key {
						t.Errorf("got %s for Select.Conditionals[%d].Key, expected %s", answer.Conditionals[i].Key, i, expectedCondition.Key)
					}
					if expectedCondition.Operator != answer.Conditionals[i].Operator {
						t.Errorf("got %s for Select.Conditionals[%d].Operator, expected %s", answer.Conditionals[i].Operator, i, expectedCondition.Operator)
					}
					if expectedCondition.Value != answer.Conditionals[i].Value {
						t.Errorf("got %s for Select.Conditionals[%d].Value, expected %s", answer.Conditionals[i].Value, i, expectedCondition.Value)
					}
					if expectedCondition.Extension != answer.Conditionals[i].Extension {
						t.Errorf("got %s for Select.Conditionals[%d].Extension, expected %s", answer.Conditionals[i].Extension, i, expectedCondition.Extension)
					}
				}
			}

			if len(answer.OrderBys) != len(expected.OrderBys) {
				t.Errorf("got %d number of orderBys for Select.OrderBys, expected %d", len(answer.OrderBys), len(expected.OrderBys))
			} else {
				for i, expectedOrderBy := range expected.OrderBys {
					if expectedOrderBy.Key != answer.OrderBys[i].Key {
						t.Errorf("got %s for Select.OrderBys[%d].Key, expected %s", answer.OrderBys[i].Key, i, expectedOrderBy.Key)
					}
					if expectedOrderBy.IsDescend != answer.OrderBys[i].IsDescend {
						t.Errorf("got %#v for Select.OrderBys[%d].IsDescend, expected %#v", answer.OrderBys[i].IsDescend, i, expectedOrderBy.IsDescend)
					}
				}
			}

			if len(answer.Joins) != len(expected.Joins) {
				t.Errorf("got %d number of joins for Select.Joinss, expected %d", len(answer.Joins), len(expected.Joins))
			} else {
				for i, expectedJoin := range expected.Joins {
					t.Errorf("got %d for Select.Joins[%d].Type, expected %d", answer.Joins[i].Type, i, expectedJoin.Type)
				}

			}

		})
	}
}