mysql> SELECT -> stu_name, -> course, -> MAX(CASE course WHEN 'Java' THEN score ELSE 0 END) Java, -> MAX(CASE course WHEN 'Html' THEN score ELSE 0 END) Html, -> MAX(CASE course WHEN 'Jsp' THEN score ELSE 0 END) Jsp, -> MAX(CASE course WHEN 'Spring' THEN score ELSE 0 END) Spring -> FROM score -> GROUP BY stu_name; ERROR 1055 (42000): Expression #2 of SELECT list is not in GROUP BY clause and contains nonaggregated column 'course.score.course' which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_mode=only_full_group_by

无效，必须出现在 GROUP BY 子句中或是聚合函数中。这个查询语句中的错误是由于列 stu_name, course, score 的来源没有明确指定而导致的。正确的语句应该是：

SELECT stu_name, course, MAX(CASE course WHEN 'Java' THEN score ELSE 0 END) Java,
MAX(CASE course WHEN 'Html' THEN score ELSE 0 END) Html,
MAX(CASE course WHEN 'Jsp' THEN score ELSE 0 END) Jsp,
MAX(CASE course WHEN 'Spring' THEN score ELSE 0 END) Spring
FROM score
GROUP BY stu_name, course;

这个查询语句的目的是根据学生的名字，汇总他们的成绩，案例中针对不同的课程使用了不同的聚合函数，最后用 GROUP BY 子句对学生名字进行分组，使得每个学生只有一条数据，汇总了他们所有课程的成绩。

相关问题

delimiter // mysql> create procedure proc_stu_test() -> begin -> select count(*) from student -> end //

这是一个 MySQL 存储过程的创建语句。该存储过程名为 `proc_stu_test`，没有输入参数，执行的操作是查询 `student` 表中的记录数，并将结果返回。存储过程的语法如下：

CREATE PROCEDURE procedure_name([IN parameter_name data_type[, ...]])
BEGIN
-- 存储过程的操作
END;

其中，`procedure_name` 是存储过程的名称，`parameter_name` 是输入参数的名称，`data_type` 是输入参数的数据类型。在这个例子中，存储过程没有输入参数，因此参数列表为空。`BEGIN` 和 `END` 之间是存储过程的操作。在这个例子中，存储过程的操作只是查询 `student` 表中的记录数。

void *Sort(STU *head) { p = head->next; now = head; pr = head; while (p != NULL) { while (p->next != NULL) { if ((p->score[0] + p->score[1] + p->score[2]) < (p->next->score[0] + p->next->score[1] + p->next->score[2])) { strcpy(pr->num, p->num); strcpy(pr->name, p->name); strcpy(pr->major, p->major); pr->classNo = p->classNo; pr->score[0] = p->score[0]; pr->score[1] = p->score[1]; pr->score[2] = p->score[2]; strcpy(p->num, p->next->num); strcpy(p->name, p->next->name); strcpy(p->major, p->next->major); p->classNo = p->next->classNo; p->score[0] = p->next->score[0]; p->score[1] = p->next->score[1]; p->score[2] = p->next->score[2]; strcpy(p->next->num, pr->num); strcpy(p->next->name, pr->name); strcpy(p->next->major, pr->major); p->next->classNo = pr->classNo; p->next->score[0] = pr->score[0]; p->next->score[1] = pr->score[1]; p->next->score[2] = pr->score[2]; } p = p->next; } p = now->next; now = now->next; } }

你提供的`Sort`函数实现了一个简单的冒泡排序算法来按照学生总分从高到低对链表进行排序。代码中使用了结构体成员变量之间的赋值和字符串拷贝操作。

但是你的代码存在一个问题，就是在内层循环中，你没有更新`pr`指针。这会导致每次交换后，`pr`指针都保持不变，而应该向前移动一个位置。

以下是修复这个问题的修改后的代码：

void Sort(STU *head) {
    STU *p, *now, *pr;
    p = head->next;
    now = head;
    pr = head;
    while (p != NULL) {
        while (p->next != NULL) {
            if ((p->score[0] + p->score[1] + p->score[2]) < (p->next->score[0] + p->next->score[1] + p->next->score[2])) {
                strcpy(pr->num, p->num);
                strcpy(pr->name, p->name);
                strcpy(pr->major, p->major);
                pr->classNo = p->classNo;
                pr->score[0] = p->score[0];
                pr->score[1] = p->score[1];
                pr->score[2] = p->score[2];

                strcpy(p->num, p->next->num);
                strcpy(p->name, p->next->name);
                strcpy(p->major, p->next->major);
                p->classNo = p->next->classNo;
                p->score[0] = p->next->score[0];
                p->score[1] = p->next->score[1];
                p->score[2] = p->next->score[2];

                strcpy(p->next->num, pr->num);
                strcpy(p->next->name, pr->name);
                strcpy(p->next->major, pr->major);
                p->next->classNo = pr->classNo;
                p->next->score[0] = pr->score[0];
                p->next->score[1] = pr->score[1];
                p->next->score[2] = pr->score[2];
            }
            p = p->next;
            pr = pr->next; // 添加这一行来更新pr指针
        }
        p = now->next;
        now = now->next;
    }
}

这样，`pr`指针在内层循环中会向前移动一个位置，确保下一次交换时指向正确的位置。

请记得在调用`Sort`函数时传入合适的参数。