Lets go show

```sql
BEGIN
    DECLARE i INT DEFAULT 1;

    WHILE i <= 1000 DO
        INSERT INTO member (
            username, 
            nickname, 
            email, 
            password, 
            gender, 
            mode, 
            role, 
            image_file, 
            created_at, 
            created_by, 
            updated_at, 
            updated_by, 
            score, 
            phone_number, 
            auth_email, 
            auth_phone
        ) VALUES (
            CONCAT('홍길동', i), 
            CONCAT('닉네임', i), 
            CONCAT('normal', i, '@example.com'), 
            '$2a$12$vVyp1MKvgHaS68VKu/gyjeaFqHiXzKiu8Cq5A8jeoLZzHM900.0X2', 
            'MALE', -- 성별 예제 값 (M: 남성, F: 여성)
            'MILD', -- 모드 예제 값
            'NORMAL_USER', 
            NULL,
            NOW(), -- 생성 시간
            'ADMIN', -- 생성자
            NOW(), -- 업데이트 시간
            'ADMIN', -- 업데이트자
            FLOOR(RAND() * 100), -- 점수 (0~99 랜덤 값)
            CONCAT('011', LPAD(i, 8, '0')),
            false, 
            false 
        );
        SET i = i + 1;
END WHILE;
END

```

```sql
BEGIN
    DECLARE i INT DEFAULT 1;

    WHILE i <= 1000 DO
        INSERT INTO AUTH (
            email, refresh_token, created_at, created_by, updated_at, updated_by
        ) VALUES (
            CONCAT('normal', i, '@example.com'), 
            UUID(),                           
            NOW(),                              
            'ADMIN',          
            NOW(),                             
            'ADMIN'
        );

        SET i = i + 1;
    END WHILE;
END
```

```sql
BEGIN
    DECLARE board_idx INT DEFAULT 1; -- 게시글 ID
    DECLARE member_count INT DEFAULT 1000; -- 멤버 수
    DECLARE max_boards INT DEFAULT 10000; -- 게시글 수
    DECLARE max_hearts INT DEFAULT 6; -- 게시글 좋아요 최대 수 (0~5개)
    DECLARE max_scraps INT DEFAULT 6; -- 게시글 스크랩 최대 수 (0~5개)

    -- 게시글 삽입
    WHILE board_idx <= max_boards DO
        -- 게시글 삽입
        INSERT INTO BOARD (
            member_id, title, contents, created_at, updated_at, total_like, total_scrap
        ) VALUES (
            FLOOR(RAND() * member_count) + 1, -- 랜덤 멤버
            CONCAT('Board Title ', board_idx),
            CONCAT('Content for board ', board_idx), 
            NOW(), 
            NOW(), 
            0, 
            0 
        );


        SET @last_board_id = LAST_INSERT_ID();

        -- 랜덤하게 게시글 좋아요 생성 (0~5개)
        SET @board_hearts = FLOOR(RAND() * max_hearts); -- 좋아요 수
        WHILE @board_hearts > 0 DO
            INSERT INTO BOARD_HEART (
                board_id, member_id
            ) VALUES (
                @last_board_id, -- 게시글 ID
                FLOOR(RAND() * member_count) + 1 -- 랜덤 멤버 ID
            );

            -- BOARD 테이블의 total_like 업데이트
UPDATE BOARD
SET total_like = total_like + 1
WHERE board_id = @last_board_id;

SET @board_hearts = @board_hearts - 1;
END WHILE;

        -- 랜덤하게 게시글 스크랩 생성 (0~5개)
        SET @board_scraps = FLOOR(RAND() * max_scraps); -- 스크랩 수
        WHILE @board_scraps > 0 DO
            INSERT INTO BOARD_SCRAP (
                board_id, member_id
            ) VALUES (
                @last_board_id, -- 게시글 ID
                FLOOR(RAND() * member_count) + 1 -- 랜덤 멤버 ID
            );

            -- BOARD 테이블의 total_scrap 업데이트
UPDATE BOARD
SET total_scrap = total_scrap + 1
WHERE board_id = @last_board_id;

SET @board_scraps = @board_scraps - 1;
END WHILE;

        SET board_idx = board_idx + 1;
END WHILE;
END
```

```sql
BEGIN
    DECLARE board_idx INT DEFAULT 1; -- 게시글 ID
    DECLARE reply_idx INT DEFAULT 1; -- 댓글 카운터
    DECLARE member_count INT DEFAULT 1000; -- 멤버 수
    DECLARE max_replies INT DEFAULT 10; -- 게시글당 댓글 수

    WHILE board_idx <= 10000 DO
        SET reply_idx = 1;

        WHILE reply_idx <= max_replies DO
            -- 댓글 삽입
            INSERT INTO REPLY (
                member_id, board_id, parent_id, contents, total_like, created_at, updated_at
            ) VALUES (
                FLOOR(RAND() * member_count) + 1, 
                board_idx,                        
                NULL,                            
                CONCAT('Reply content for board ', board_idx, ' reply ', reply_idx),
                0,                               
                NOW(),                           
                NOW()                             
            );

            -- 방금 삽입된 댓글의 ID 가져오기
            SET @last_reply_id = LAST_INSERT_ID();

            -- 랜덤하게 대댓글 생성 (0~3개)
            SET @sub_replies = FLOOR(RAND() * 4); -- 대댓글 수
            WHILE @sub_replies > 0 DO
                INSERT INTO REPLY (
                    member_id, board_id, parent_id, contents, total_like, created_at, updated_at
                ) VALUES (
                    FLOOR(RAND() * member_count) + 1, 
                    board_idx,                        
                    @last_reply_id,                   -- 대댓글의 parent_id
                    CONCAT('Sub-reply for reply ', @last_reply_id),
                    0,                                
                    NOW(),                            
                    NOW()                             
                );
                SET @sub_replies = @sub_replies - 1;
END WHILE;

            -- 랜덤하게 댓글 좋아요 생성 (0~5개)
            SET @hearts = FLOOR(RAND() * 6); -- 좋아요 수
            WHILE @hearts > 0 DO
                INSERT INTO REPLY_HEART (
                    reply_id, member_id
                ) VALUES (
                    @last_reply_id, -- 좋아요가 눌린 댓글 ID
                    FLOOR(RAND() * member_count) + 1 -- 랜덤 멤버
                );

                -- REPLY 테이블의 total_like 업데이트
UPDATE REPLY
SET total_like = total_like + 1
WHERE reply_id = @last_reply_id;

SET @hearts = @hearts - 1;
END WHILE;

            SET reply_idx = reply_idx + 1;
END WHILE;

        SET board_idx = board_idx + 1;
END WHILE;
END
```

```sql
BEGIN
    DECLARE member_idx INT DEFAULT 1; -- 멤버 ID
    DECLARE max_members INT DEFAULT 1000; -- 멤버 수
    DECLARE max_schedules INT DEFAULT 3; -- 각 멤버당 일정 수
    DECLARE schedule_idx INT DEFAULT 1; -- 일정 인덱스
    DECLARE schedule_id BIGINT DEFAULT NULL; -- 일정 ID
    DECLARE f_schedule_id BIGINT DEFAULT NULL; -- F_SCHEDULE ID
    DECLARE schedule_start_date DATETIME DEFAULT NULL; -- 일정 시작일
    DECLARE schedule_end_date DATETIME DEFAULT NULL; -- 일정 종료일
    DECLARE current_loop_date DATETIME DEFAULT NULL; -- 반복 중인 날짜
    DECLARE loop_date DATETIME DEFAULT NULL; -- 반복할 날짜

    WHILE member_idx <= max_members DO
        SET schedule_idx = 1;

        WHILE schedule_idx <= max_schedules DO
            -- 변수 초기화
            SET schedule_id = NULL;
            SET schedule_start_date = NULL;
            SET schedule_end_date = NULL;
            SET current_loop_date = NULL;
            SET loop_date = NULL;

            -- SCHEDULE 테이블에 일정 삽입
            INSERT INTO SCHEDULE (
                member_id, title, common_description, start_date, end_date, created_at, created_by, updated_at, updated_by, dtype
            ) VALUES (
                member_idx,
                CONCAT('Schedule ', member_idx, ' - ', schedule_idx),
                CONCAT('Description for schedule ', schedule_idx, ' of member ', member_idx),
                NOW() + INTERVAL (schedule_idx * 10) DAY,
                NOW() + INTERVAL (schedule_idx * 12) DAY,
                NOW(),
                CONCAT('normal', member_idx, '@example.com'),
                NOW(),
                CONCAT('normal', member_idx, '@example.com'),
                'fixed'
            );

            SET schedule_id = LAST_INSERT_ID();

            -- 데이터 검증
            IF schedule_id IS NULL THEN
                SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Failed to retrieve LAST_INSERT_ID.';
            END IF;

            SELECT start_date, end_date 
            INTO schedule_start_date, schedule_end_date
            FROM SCHEDULE
            WHERE SCHEDULE.schedule_id = schedule_id;

            IF schedule_start_date IS NULL OR schedule_end_date IS NULL THEN
                SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Failed to retrieve start_date or end_date.';
            END IF;

            -- F_SCHEDULE 테이블에 삽입
            INSERT INTO F_SCHEDULE (schedule_id) VALUES (schedule_id);
            SET f_schedule_id = LAST_INSERT_ID();

            -- 반복 일정 생성
            SET current_loop_date = schedule_start_date;

            WHILE current_loop_date <= schedule_end_date DO
                SET loop_date = CONCAT(DATE(current_loop_date), ' 13:00:00');

                INSERT INTO F_SCHEDULE_DETAIL (
                    schedule_id, detail_description, start_date, end_date, created_by, created_at, updated_by, updated_at
                ) VALUES (
                    f_schedule_id,
                    CONCAT('Detail description for schedule ', schedule_idx, ' of member ', member_idx),
                    loop_date,
                    DATE_ADD(loop_date, INTERVAL 1 HOUR),
                    CONCAT('normal', member_idx, '@example.com'),
                    NOW(),
                    CONCAT('normal', member_idx, '@example.com'),
                    NOW()
                );

                SET current_loop_date = DATE_ADD(current_loop_date, INTERVAL 1 DAY);
            END WHILE;

            SET schedule_idx = schedule_idx + 1;
        END WHILE;

        SET member_idx = member_idx + 1;
    END WHILE;
END
```

```sql
BEGIN
    DECLARE member_idx INT DEFAULT 1; -- 멤버 ID
    DECLARE max_members INT DEFAULT 1000; -- 멤버 수
    DECLARE max_schedules INT DEFAULT 100; -- 각 멤버당 일정 수
    DECLARE schedule_idx INT DEFAULT 1; -- 일정 인덱스
    DECLARE random_start_date DATETIME; -- 랜덤 시작일
    DECLARE random_end_date DATETIME; -- 랜덤 종료일

    -- 각 멤버에 대해 일정 생성
    WHILE member_idx <= max_members DO
        SET schedule_idx = 1;

        WHILE schedule_idx <= max_schedules DO
            -- 시작일 생성 (무작위로)
            SET random_start_date = 
                '2023-01-01 00:00:00' + INTERVAL FLOOR(RAND() * 730) DAY + INTERVAL FLOOR(RAND() * 24) HOUR;

            SET random_end_date = random_start_date + INTERVAL 2 HOUR;

            INSERT INTO SCHEDULE (
                member_id, title, common_description, start_date, end_date, created_at, created_by, updated_at, updated_by, dtype
            ) VALUES (
                member_idx, -- 멤버 ID
                CONCAT('Schedule ', member_idx, ' - ', schedule_idx), 
                CONCAT('This is a Variable schedule for member ', member_idx), 
                random_start_date, -- 랜덤 시작일
                random_end_date, -- 종료일 (시작일 + 2시간)
                NOW(), -- 생성 시간
                CONCAT('normal', member_idx, '@example.com'), 
                NOW(), -- 수정 시간
                CONCAT('normal', member_idx, '@example.com'),
                'fixed' -- dtype
            );

            -- V_SCHEDULE 테이블에 삽입
            INSERT INTO V_SCHEDULE (schedule_id)
            VALUES (LAST_INSERT_ID());

            SET schedule_idx = schedule_idx + 1;
        END WHILE;

        SET member_idx = member_idx + 1;
    END WHILE;
END $$

```

```scala
class LoginSimulation extends Simulation {

  // HTTP Protocol 설정
  val httpProtocol = http
    .baseUrl("http://localhost:8080") // API의 기본 URL
    .contentTypeHeader("application/x-www-form-urlencoded") // Content-Type 설정

  // 1000명의 순차적인 이메일 생성
  val userFeeder = (1 to 1000).map(i => Map(
    "email" -> s"normal$i@example.com", 
    "password" -> "password1"          
  )).iterator 
  
  val debugFeeder = exec { session =>
    val email = session("email").asOption[String]
    println(s"Feeder supplied email: ${email.getOrElse("No email in session")}")
    session
  }

  // 1. 로그인 요청
  val login = exec(debugFeeder) 
    .exec { session =>
      val email = session("email").as[String]
      val password = session("password").as[String]
      println(s"Attempting login with email: $email and password: $password")
      session
    }
    .exec(
      http("Login Request")
        .post("/login") // 로그인 API 엔드포인트
        .formParam("email", session => session("email").as[String]) 
        .formParam("password", session => session("password").as[String]) 
        .check(
          status.is(200),  
          header("Authorization").saveAs("authToken") // Authorization 헤더 추출
        )
    ).exitHereIfFailed 

  // 2. 보호된 리소스 요청
  val authenticatedRequest = exec { session =>
    val authToken = session("authToken").asOption[String]
    println(s"Using Authorization token: ${authToken.getOrElse("No token in session")}")
    val randomTitle = scala.util.Random.alphanumeric.take(10).mkString
    val randomDescription = scala.util.Random.alphanumeric.take(20).mkString
    val randomTotalAmount = scala.util.Random.between(100, 301) // 100~300 사이의 랜덤 값
    session
      .set("randomTitle", randomTitle)
      .set("randomDescription", randomDescription)
      .set("randomTotalAmount", randomTotalAmount)
  }.exec(
    http("Protected Resource Request")
      .post("/schedule/normal") 
      .header("Authorization", session => session("authToken").as[String])
      .header("Content-type", "application/json")
      .body(StringBody(session => {
        val title = session("randomTitle").as[String]
        val description = session("randomDescription").as[String]
        val totalAmount = session("randomTotalAmount").as[Int]

        s"""
        {
          "title": "$title",
          "commonDescription": "$description",
          "startDate": "2024-10-30",
          "endDate": "2024-11-30",
          "bufferTime": "01:00:00",
          "performInDay": "04:00:00",
          "isIncludeSaturday": true,
          "isIncludeSunday": true,
          "totalAmount": $totalAmount,
          "performInWeek": 4
        }
        """
      }))
      .asJson 
      .check(status.is(201)) 
  )

  val scn = scenario("Login and Access Protected Resource")
    .feed(userFeeder)    
    .exec(login)         
    .pause(1)            
    .exec(authenticatedRequest) 

  setUp(
    scn.inject(
      atOnceUsers(1000)
    ).protocols(httpProtocol)
  )
}
```