Function TestSQLAnalyzer_ComplexityMetrics

cmd/gosqlx/cmd/sql_analyzer_test.go:260–339

(t *testing.T)

}

func TestSQLAnalyzer_ComplexityMetrics(t *testing.T) {
	testCases := []struct {
		name               string
		sql                string
		expectedComplexity string // LOW, MEDIUM, HIGH, VERY_HIGH
		minJoinCount       int
		minFunctionCount   int
	}{
		{
			name:               "Simple query",
			sql:                "SELECT name FROM users WHERE active = true",
			expectedComplexity: "MEDIUM", // Current analyzer seems to report medium for simple queries
			minJoinCount:       0,
			minFunctionCount:   0,
		},
		{
			name:               "Medium complexity with JOINs",
			sql:                "SELECT u.name, p.title FROM users u JOIN posts p ON u.id = p.user_id WHERE u.active = true",
			expectedComplexity: "MEDIUM", // Should be medium with JOIN
			minJoinCount:       1,
			minFunctionCount:   0,
		},
		{
			name: "High complexity with multiple JOINs",
			sql: `SELECT u.name, p.title FROM users u 
			       JOIN posts p ON u.id = p.user_id 
			       JOIN categories c ON p.category_id = c.id
			       WHERE u.active = true`,
			expectedComplexity: "MEDIUM",
			minJoinCount:       2,
			minFunctionCount:   0,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Parse and analyze
			tkz := tokenizer.GetTokenizer()
			defer tokenizer.PutTokenizer(tkz)

			tokens, err := tkz.Tokenize([]byte(tc.sql))
			if err != nil {
				t.Fatalf("Tokenization failed: %v", err)
			}

			p := parser.NewParser()
			astObj := ast.NewAST()
			defer ast.ReleaseAST(astObj)

			result, err := p.ParseFromModelTokens(tokens)
			if err != nil {
				t.Fatalf("Parsing failed: %v", err)
			}

			astObj.Statements = result.Statements

			analyzer := NewSQLAnalyzer()
			report, err := analyzer.Analyze(astObj)