more query tests using sqlite3 in-memory db

Signed-off-by: oppiliappan <[e-mail]>

go.mod

···
 module tangled.sh/oppi.li/norm
 
 go 1.24.1
+
+require github.com/mattn/go-sqlite3 v1.14.28

go.sum

···
+github.com/mattn/go-sqlite3 v1.14.28 h1:ThEiQrnbtumT+QMknw63Befp/ce/nUPgBPMlRFEum7A=
+github.com/mattn/go-sqlite3 v1.14.28/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=

query_test.go

···
 package norm
 
 import (
+	"database/sql"
 	"testing"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
 )
 
 func TestIdentExpr(t *testing.T) {
···
 		}
 	}
 }
+
+// setupTestDB creates an in-memory SQLite database with test data
+func setupTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+
+	// Create users table
+	_, err = db.Exec(`
+		CREATE TABLE users (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			name TEXT NOT NULL,
+			age INTEGER NOT NULL,
+			email TEXT UNIQUE NOT NULL,
+			department TEXT,
+			active BOOLEAN DEFAULT TRUE,
+			salary REAL,
+			created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+		)
+	`)
+	if err != nil {
+		t.Fatalf("Failed to create users table: %v", err)
+	}
+
+	// Create departments table
+	_, err = db.Exec(`
+		CREATE TABLE departments (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			name TEXT NOT NULL,
+			budget REAL
+		)
+	`)
+	if err != nil {
+		t.Fatalf("Failed to create departments table: %v", err)
+	}
+
+	// Insert test data
+	users := []struct {
+		name, email, department string
+		age                     int
+		active                  bool
+		salary                  float64
+	}{
+		{"John Doe", "[e-mail]", "Engineering", 30, true, 75000.0},
+		{"Jane Smith", "[e-mail]", "Marketing", 25, true, 65000.0},
+		{"Bob Johnson", "[e-mail]", "Engineering", 35, false, 80000.0},
+		{"Alice Brown", "[e-mail]", "Sales", 28, true, 70000.0},
+		{"Charlie Wilson", "[e-mail]", "Engineering", 32, true, 85000.0},
+		{"Diana Prince", "[e-mail]", "Marketing", 29, false, 68000.0},
+	}
+
+	for _, user := range users {
+		_, err = db.Exec(`
+			INSERT INTO users (name, email, department, age, active, salary)
+			VALUES (?, ?, ?, ?, ?, ?)
+		`, user.name, user.email, user.department, user.age, user.active, user.salary)
+		if err != nil {
+			t.Fatalf("Failed to insert user %s: %v", user.name, err)
+		}
+	}
+
+	// Insert departments
+	departments := []struct {
+		name   string
+		budget float64
+	}{
+		{"Engineering", 500000.0},
+		{"Marketing", 300000.0},
+		{"Sales", 400000.0},
+	}
+
+	for _, dept := range departments {
+		_, err = db.Exec(`
+			INSERT INTO departments (name, budget)
+			VALUES (?, ?)
+		`, dept.name, dept.budget)
+		if err != nil {
+			t.Fatalf("Failed to insert department %s: %v", dept.name, err)
+		}
+	}
+
+	return db
+}
+
+func TestSelectIntegration_BasicQueries(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	tests := []struct {
+		name         string
+		builder      func() select_
+		expectedRows int
+	}{
+		{
+			name: "Select all users",
+			builder: func() select_ {
+				return Select("*").From("users")
+			},
+			expectedRows: 6,
+		},
+		{
+			name: "Select active users only",
+			builder: func() select_ {
+				return Select("name", "email").
+					From("users").
+					Where(Eq("active", true))
+			},
+			expectedRows: 4,
+		},
+		{
+			name: "Select users in Engineering",
+			builder: func() select_ {
+				return Select("name", "age").
+					From("users").
+					Where(Eq("department", "Engineering"))
+			},
+			expectedRows: 3,
+		},
+		{
+			name: "Select users with age > 30",
+			builder: func() select_ {
+				return Select("name", "age").
+					From("users").
+					Where(Gt("age", 30))
+			},
+			expectedRows: 2,
+		},
+		{
+			name: "Select users with salary between 70000 and 80000",
+			builder: func() select_ {
+				return Select("name", "salary").
+					From("users").
+					Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0)))
+			},
+			expectedRows: 3,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			s := test.builder()
+			sql, args, err := s.Build()
+			if err != nil {
+				t.Fatalf("Failed to build query: %v", err)
+			}
+
+			rows, err := db.Query(sql, args...)
+			if err != nil {
+				t.Fatalf("Failed to execute query: %v", err)
+			}
+			defer rows.Close()
+
+			count := 0
+			for rows.Next() {
+				count++
+			}
+
+			if count != test.expectedRows {
+				t.Errorf("Expected %d rows, got %d", test.expectedRows, count)
+			}
+		})
+	}
+}
+
+func TestSelectIntegration_ComplexQueries(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	t.Run("Complex WHERE with AND/OR", func(t *testing.T) {
+		s := Select("name", "department", "age").
+			From("users").
+			Where(
+				Eq("department", "Engineering").
+					And(Gt("age", 30)).
+					Or(Eq("department", "Marketing").And(Lt("age", 30))),
+			)
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		var results []struct {
+			name, department string
+			age              int
+		}
+
+		for rows.Next() {
+			var name, department string
+			var age int
+			if err := rows.Scan(&name, &department, &age); err != nil {
+				t.Fatalf("Failed to scan row: %v", err)
+			}
+			results = append(results, struct {
+				name, department string
+				age              int
+			}{name, department, age})
+		}
+
+		// Should get:
+		// - Bob Johnson (Engineering, 35)
+		// - Charlie Wilson (Engineering, 32)
+		// - Jane Smith (Marketing, 25)
+		// - Diana Prince (Marketing, 29)
+		if len(results) != 4 {
+			t.Errorf("Expected 4 results, got %d", len(results))
+		}
+	})
+
+	t.Run("ORDER BY multiple columns", func(t *testing.T) {
+		s := Select("name", "department", "age").
+			From("users").
+			OrderBy("department", Ascending).
+			OrderBy("age", Descending)
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		var results []struct {
+			name, department string
+			age              int
+		}
+
+		for rows.Next() {
+			var name, department string
+			var age int
+			if err := rows.Scan(&name, &department, &age); err != nil {
+				t.Fatalf("Failed to scan row: %v", err)
+			}
+			results = append(results, struct {
+				name, department string
+				age              int
+			}{name, department, age})
+		}
+
+		if len(results) != 6 {
+			t.Fatalf("Expected 6 results, got %d", len(results))
+		}
+
+		// First result should be from Engineering (alphabetically first) with highest age
+		if results[0].department != "Engineering" {
+			t.Errorf("Expected first result to be from Engineering, got %s", results[0].department)
+		}
+		if results[0].age != 35 {
+			t.Errorf("Expected first result age to be 35, got %d", results[0].age)
+		}
+	})
+
+	t.Run("GROUP BY with COUNT", func(t *testing.T) {
+		s := Select("department", "COUNT(*) as user_count").
+			From("users").
+			GroupBy("department").
+			OrderBy("user_count", Descending)
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		var results []struct {
+			department string
+			count      int
+		}
+
+		for rows.Next() {
+			var department string
+			var count int
+			if err := rows.Scan(&department, &count); err != nil {
+				t.Fatalf("Failed to scan row: %v", err)
+			}
+			results = append(results, struct {
+				department string
+				count      int
+			}{department, count})
+		}
+
+		if len(results) != 3 {
+			t.Errorf("Expected 3 departments, got %d", len(results))
+		}
+
+		// Engineering should have the most users (3)
+		if results[0].department != "Engineering" || results[0].count != 3 {
+			t.Errorf("Expected Engineering with 3 users first, got %s with %d users", results[0].department, results[0].count)
+		}
+	})
+
+	t.Run("LIMIT with ORDER BY", func(t *testing.T) {
+		s := Select("name", "salary").
+			From("users").
+			Where(Eq("active", true)).
+			OrderBy("salary", Descending).
+			Limit(2)
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		var results []struct {
+			name   string
+			salary float64
+		}
+
+		for rows.Next() {
+			var name string
+			var salary float64
+			if err := rows.Scan(&name, &salary); err != nil {
+				t.Fatalf("Failed to scan row: %v", err)
+			}
+			results = append(results, struct {
+				name   string
+				salary float64
+			}{name, salary})
+		}
+
+		if len(results) != 2 {
+			t.Errorf("Expected 2 results, got %d", len(results))
+		}
+
+		// Should get Charlie Wilson (85000) and John Doe (75000)
+		if results[0].salary != 85000.0 {
+			t.Errorf("Expected highest salary to be 85000, got %f", results[0].salary)
+		}
+		if results[1].salary != 75000.0 {
+			t.Errorf("Expected second highest salary to be 75000, got %f", results[1].salary)
+		}
+	})
+}
+
+func TestSelectIntegration_DataTypes(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	t.Run("String comparisons", func(t *testing.T) {
+		s := Select("name", "email").
+			From("users").
+			Where(Eq("name", "John Doe"))
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		count := 0
+		for rows.Next() {
+			count++
+		}
+
+		if count != 1 {
+			t.Errorf("Expected 1 result, got %d", count)
+		}
+	})
+
+	t.Run("Boolean comparisons", func(t *testing.T) {
+		s := Select("name").
+			From("users").
+			Where(Eq("active", false))
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		count := 0
+		for rows.Next() {
+			count++
+		}
+
+		if count != 2 {
+			t.Errorf("Expected 2 inactive users, got %d", count)
+		}
+	})
+
+	t.Run("Float comparisons", func(t *testing.T) {
+		s := Select("name", "salary").
+			From("users").
+			Where(Gte("salary", 80000.0))
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		count := 0
+		for rows.Next() {
+			count++
+		}
+
+		if count != 2 {
+			t.Errorf("Expected 2 users with salary >= 80000, got %d", count)
+		}
+	})
+}
+
+func TestSelectIntegration_ErrorHandling(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	t.Run("Invalid table name", func(t *testing.T) {
+		s := Select("*").From("nonexistent_table")
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		_, err = db.Query(sql, args...)
+		if err == nil {
+			t.Error("Expected error for nonexistent table, got nil")
+		}
+	})
+
+	t.Run("Invalid column name", func(t *testing.T) {
+		s := Select("nonexistent_column").From("users")
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		_, err = db.Query(sql, args...)
+		if err == nil {
+			t.Error("Expected error for nonexistent column, got nil")
+		}
+	})
+}
+
+func TestSelectIntegration_PerformanceBaseline(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	// Add more test data for performance testing
+	start := time.Now()
+	for i := 0; i < 1000; i++ {
+		_, err := db.Exec(`
+			INSERT INTO users (name, email, department, age, active, salary)
+			VALUES (?, ?, ?, ?, ?, ?)
+		`, "User"+string(rune(i)), "user"+string(rune(i))+"@example.com", "Engineering", 25+i%15, i%2 == 0, 50000.0+float64(i*100))
+		if err != nil {
+			t.Fatalf("Failed to insert test user: %v", err)
+		}
+	}
+	insertTime := time.Since(start)
+	t.Logf("Inserted 1000 users in %v", insertTime)
+
+	t.Run("Simple select performance", func(t *testing.T) {
+		s := Select("name", "email").
+			From("users").
+			Where(Eq("active", true))
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		start := time.Now()
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		count := 0
+		for rows.Next() {
+			count++
+		}
+		queryTime := time.Since(start)
+
+		t.Logf("Selected %d rows in %v", count, queryTime)
+		if queryTime > time.Millisecond*100 {
+			t.Logf("Query took longer than expected: %v", queryTime)
+		}
+	})
+
+	t.Run("Complex query performance", func(t *testing.T) {
+		s := Select("name", "department", "salary").
+			From("users").
+			Where(
+				Eq("active", true).
+					And(Gt("salary", 60000.0)).
+					Or(Eq("department", "Engineering")),
+			).
+			OrderBy("salary", Descending).
+			Limit(50)
+
+		sql, args, err := s.Build()
+		if err != nil {
+			t.Fatalf("Failed to build query: %v", err)
+		}
+
+		start := time.Now()
+		rows, err := db.Query(sql, args...)
+		if err != nil {
+			t.Fatalf("Failed to execute query: %v", err)
+		}
+		defer rows.Close()
+
+		count := 0
+		for rows.Next() {
+			count++
+		}
+		queryTime := time.Since(start)
+
+		t.Logf("Complex query returned %d rows in %v", count, queryTime)
+		if queryTime > time.Millisecond*200 {
+			t.Logf("Complex query took longer than expected: %v", queryTime)
+		}
+	})
+}