목차

문자열 함수

SQL의 문자열 함수는 문자 데이터를 조작하고 처리하는 데 사용됩니다. 연결, 자르기, 대소문자 변환, 하위 문자열 추출 등을 수행할 수 있습니다. 특정 구문은 DBMS(데이터베이스 관리 시스템)마다 약간씩 다를 수 있지만 대부분의 기본 문자열 함수는 대부분의 DBMS에서 공통적입니다. 다음은 일반적으로 사용되는 SQL 문자열 함수입니다.

1 . CONCAT(str1, str2, ...): 두 개 이상의 문자열을 연결합니다.

SELECT CONCAT('Hello', ' ', 'World!') AS result;

2. SUBSTRING(str, start, length): 지정된 위치에서 시작하여 지정된 길이로 문자열에서 하위 문자열을 추출합니다.

SELECT SUBSTRING('Hello, World!', 1, 5) AS result;

3. LENGTH(str): 문자열의 길이를 반환합니다.

SELECT LENGTH('Hello, World!') AS result;

4. TRIM([LEADING | TRAILING | BOTH] [chars] FROM str): 문자열의 처음, 끝 또는 양쪽에서 지정된 문자(또는 기본적으로 공백)를 제거합니다.

SELECT TRIM('  Hello, World!  ') AS result;

5. UPPER(str): 문자열을 대문자로 변환합니다.

SELECT UPPER('Hello, World!') AS result;

6. LOWER(str): 문자열을 소문자로 변환합니다.

SELECT LOWER('Hello, World!') AS result;

7. REPLACE(str, search_str, replace_str): 검색 문자열의 모든 항목을 입력 문자열의 대체 문자열로 바꿉니다.

SELECT REPLACE('Hello, World!', 'World', 'SQL') AS result;

8. POSITION(substr IN str): 문자열 내에서 하위 문자열이 처음 나타나는 위치를 반환합니다.

SELECT POSITION('World' IN 'Hello, World!') AS result;

9. CHAR_LENGTH(str) 또는 CHARACTER_LENGTH(str): 문자열의 문자 수를 반환합니다. 이 수는 멀티바이트 문자 집합의 바이트 길이와 다를 수 있습니다.

SELECT CHAR_LENGTH('Hello, World!') AS result;

10. LTRIM(str): 문자열에서 선행 공백을 제거합니다.

SELECT LTRIM('  Hello, World!') AS result;

11. RTRIM(str): 문자열에서 후행 공백을 제거합니다.

SELECT RTRIM('Hello, World!  ') AS result;

12. LEFT(str, n): 문자열의 왼쪽부터 처음 n자를 반환합니다.

SELECT LEFT('Hello, World!', 5) AS result;

13. RIGHT(str, n): 문자열의 오른쪽부터 처음 n자를 반환합니다.

SELECT RIGHT('Hello, World!', 6) AS result;

14. REVERSE(str): 문자열의 문자를 반대로 바꿉니다.

SELECT REVERSE('Hello, World!') AS result;

15. ASCII(str): 문자열에서 첫 번째 문자의 ASCII 값을 반환합니다.

SELECT ASCII('A') AS result;

16. CHAR(ascii_code): 제공된 ASCII 코드에 해당하는 문자를 반환합니다.

SELECT CHAR(65) AS result;

17. STRCMP(str1, str2): 두 문자열을 비교하여 같으면 0, str1이 str2보다 작으면 음수 값, str1이 str2보다 크면 양수 값을 반환합니다.

SELECT STRCMP('Hello', 'World') AS result;

18. CONCAT_WS(separator, str1, str2, ...): 지정된 구분 기호를 사용하여 두 개 이상의 문자열을 연결합니다.

SELECT CONCAT_WS(', ', 'Hello', 'World') AS result;

19. SUBSTR_COUNT(str, substr): 문자열 내 하위 문자열의 발생 횟수를 반환합니다.(SQL에서는 지원하지 않고, Oracle에서 사용됩니다. 대신 3, 7번을 사용하여 비슷한 결과를 얻을 수 있습니다.)

SELECT SUBSTR_COUNT('Hello, World!', 'l') AS result;

20. INSTR(str, substr): 문자열 내에서 하위 문자열이 처음 나타나는 위치를 반환하거나 하위 문자열을 찾을 수 없는 경우 0을 반환합니다.

SELECT INSTR('Hello, World!', 'World') AS result;

21. REGEXP_REPLACE(str, pattern, replacement): 정규식을 사용하여 문자열 내의 패턴 발생을 지정된 대체 문자열로 바꿉니다.

SELECT REGEXP_REPLACE('Hello, World!', '[aeiou]', '') AS result;

22. SQL은 NULL 값을 처리하기 위한 함수를 제공합니다. 이러한 함수는 기본값을 제공하거나 특정 작업을 수행하여 데이터의 NULL 값을 관리하는 데 도움이 됩니다. 다음은 예제와 함께 각 기능에 대한 설명입니다.

22-1. ISNULL

ISNULL은 SQL Server 및 MySQL 전용 함수입니다. 두 가지 인수가 필요합니다. 첫 번째 인수가 NULL이면 두 번째 인수를 반환합니다. 첫 번째 인수가 NULL이 아니면 첫 번째 인수를 반환합니다. NULL 값을 기본값으로 바꾸는 데 유용합니다.

예시(SQL server 기준)

SELECT ProductID, ProductName, ISNULL(Price, 0) AS Price
FROM Products;

예시(MySQL 기준)

SELECT ProductID, ProductName, IFNULL(Price, 0) AS Price
FROM Products;

두 예에서 ISNULL 함수는 Price 열의 NULL 값을 0으로 바꿉니다.


22-2. COALESCE

COALESCE는 SQL Server, MySQL, PostgreSQL 및 Oracle과 같은 다양한 DBMS에서 작동하는 보다 일반적인 기능입니다. 여러 인수를 사용하고 NULL이 아닌 첫 번째 인수를 반환합니다. 모든 인수가 NULL이면 NULL을 반환합니다.

SELECT ProductID, ProductName, COALESCE(Price, DiscountedPrice, 0) AS Price
FROM Products;

이 예제에서 COALESCE 함수는 각 행에 대해 Price 열과 DiscountedPrice 열을 확인합니다. Price가 NULL이 아니면 Price를 반환합니다. Price가 NULL이면 DiscountedPrice를 확인합니다. DiscountedPrice도 NULL이면 0을 반환합니다. 이러한 방식으로 COALESCE는 NULL 값을 ISNULL 함수보다 유연하게 관리할 수 있도록 도와줍니다.

목차

1. 서브 쿼리 사용 예시
2. 유형에 따른 분류
3. 자주 발생하는 실수

서브 쿼리 사용 예시

서브 쿼리는 내부 쿼리의 결과를 기반으로 데이터를 필터링, 검색 또는 조작하는 데 자주 사용되는 다른 쿼리 내에 포함된 쿼리입니다. 서브 쿼리는 SELECT, FROM, WHERE 및 HAVING 절과 같은 SQL 쿼리의 다양한 부분에서 사용할 수 있습니다. 다음은 각 절에서 서브 쿼리를 사용하는 방법에 대한 몇 가지 예입니다.

1. SELECT의 서브 쿼리
SELECT 절의 서브 쿼리를 사용하면 서브 쿼리 결과를 기본 쿼리 결과의 열로 포함할 수 있습니다.

SELECT first_name, last_name,
       (SELECT COUNT(*) FROM orders WHERE orders.customer_id = customers.customer_id)
       AS order_count
FROM customers;

이 쿼리는 고객 테이블에서 first_name 및 last_name 열을 검색하고 각 고객이 주문한 수를 포함하는 열을 추가합니다.

2. FROM의 서브 쿼리
FROM 절의 서브 쿼리를 사용하면 기본 쿼리에서 사용할 임시 테이블 또는 보기를 만들 수 있습니다.

SELECT emp.first_name, emp.last_name, emp.salary
FROM (SELECT * FROM employees WHERE salary > 50000) AS emp
ORDER BY emp.salary DESC;

이 쿼리는 급여가 50,000보다 큰 직원을 포함하는 'emp'라는 임시 테이블에서 first_name, last_name 및 급여 열을 검색합니다.

3. WHERE의 서브 쿼리
WHERE 절의 서브 쿼리를 사용하면 서브 쿼리의 결과를 기반으로 기본 쿼리의 결과를 필터링할 수 있습니다.

SELECT first_name, last_name, salary
FROM employees
WHERE department_id IN (SELECT department_id FROM departments WHERE location = 'New York');

이 쿼리는 뉴욕에 위치한 부서에서 근무하는 직원의 이름, 성, 급여 열을 검색합니다.

4. HAVING의 서브 쿼리
HAVING 절의 서브 쿼리를 사용하면 서브 쿼리 결과를 기반으로 GROUP BY 쿼리 결과를 필터링할 수 있습니다.

SELECT department_id, COUNT(*)
FROM employees
GROUP BY department_id
HAVING COUNT(*) > (SELECT AVG(employee_count) FROM
                  (SELECT department_id, COUNT(*) AS employee_count
                   FROM employees
                   GROUP BY department_id) AS dept_counts);

이 쿼리는 부서_id 및 각 부서의 직원 수를 검색하지만 직원 수가 부서당 평균 직원 수보다 많은 부서만 표시합니다.

5. GROUP BY의 서브 쿼리
일반적으로 GROUP BY 절에서 직접 서브 쿼리를 사용하지 않습니다. 그러나 SELECT, FROM 또는 HAVING 절에서 서브 쿼리를 사용하여 기본 쿼리의 그룹화에 영향을 줄 수 있습니다.

SELECT d.department_name, COUNT(e.employee_id) AS employee_count
FROM employees e
INNER JOIN departments d ON e.department_id = d.department_id
WHERE e.salary > (SELECT AVG(salary) FROM employees)
GROUP BY d.department_name;

이 쿼리는 부서_이름과 평균 급여보다 높은 급여를 받는 직원 수를 부서_이름별로 그룹화하여 검색합니다.

6. ORDER BY의 서브 쿼리
ORDER BY 절에서 서브 쿼리를 사용하여 서브 쿼리의 결과를 기반으로 기본 쿼리의 결과를 정렬할 수 있습니다.

SELECT customer_id, first_name, last_name
FROM customers
ORDER BY (SELECT SUM(amount) FROM orders WHERE orders.customer_id = customers.customer_id) DESC;

이 쿼리는 고객 테이블에서 customer_id, first_name 및 last_name 열을 검색하여 결과를 각 고객이 소비한 총 금액을 기준으로 내림차순으로 정렬합니다.

7. INSERT의 서브 쿼리
INSERT 문에서 서브 쿼리를 사용하여 다른 테이블의 데이터 또는 쿼리 결과를 새 테이블에 삽입할 수 있습니다.

INSERT INTO high_salary_employees (employee_id, first_name, last_name, salary)
SELECT employee_id, first_name, last_name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);

이 쿼리는 평균 급여보다 높은 급여를 받는 직원의 employee_id, first_name, last_name 및 급여 열을 'high_salary_employees'라는 새 테이블에 삽입합니다.

8. UPDATE의 서브 쿼리
UPDATE 문에서 서브 쿼리를 사용하여 쿼리 결과에 따라 테이블을 업데이트할 수 있습니다.

UPDATE employees
SET salary = salary * 1.1
WHERE employee_id IN (SELECT employee_id
                      FROM employees
                      WHERE department_id = (SELECT department_id
                                             FROM departments
                                             WHERE department_name = 'IT'));

이 쿼리는 'IT' 부서 직원의 급여를 10% 인상하여 업데이트합니다. 부질의는 'IT' 부서의 department_id를 찾는 데 사용되며 또 다른 부질의는 해당 부서 직원의 employee_id를 찾는 데 사용됩니다.

이러한 예제는 다양한 SQL 문에서 서브 쿼리를 사용하여 보다 복잡하고 유연한 쿼리를 만드는 방법을 보여줍니다.

유형에 따른 분류

서브 쿼리는 반환하는 값의 유형에 따라 분류할 수 있습니다. 반환 값에 따라 세 가지 기본 유형의 서브 쿼리가 있습니다.

1. 스칼라(Scalar) 서브 쿼리:
스칼라 서브 쿼리는 단일 값(하나의 행과 하나의 열)을 반환합니다. SELECT, WHERE 및 HAVING 절과 같이 단일 값을 반환하는 표현식이 허용되는 모든 곳에서 사용할 수 있습니다.

SELECT first_name, last_name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM employees);

이 예에서 서브 쿼리는 모든 직원의 평균 급여(단일 값)를 반환하고 기본 쿼리는 평균보다 급여가 높은 직원을 검색합니다.

2. 행(Row) 서브 쿼리
행 서브 쿼리는 여러 열이 있는 단일 행을 반환합니다. =, <>, >, <, >= 및 <=와 같이 전체 행을 비교하는 비교 연산자에 사용할 수 있습니다.

SELECT first_name, last_name, salary
FROM employees
WHERE (employee_id, salary) = (SELECT employee_id, MAX(salary) FROM employees);

이 쿼리는 급여가 가장 높은 직원을 검색합니다. 서브 쿼리는 employee_id 및 최대 급여가 포함된 단일 행을 반환한 다음 기본 쿼리의 각 행과 비교합니다.

3. 테이블(Table) 서브 쿼리
테이블 서브 쿼리는 테이블(여러 행 및 여러 열)을 반환합니다. FROM, WHERE 및 HAVING 절은 물론 IN, EXISTS 및 NOT EXISTS 연산자와 함께 사용할 수 있습니다.

SELECT first_name, last_name, salary
FROM employees
WHERE department_id IN (SELECT department_id FROM departments WHERE location = 'New York');

이 쿼리는 뉴욕에 위치한 부서에서 근무하는 직원을 검색합니다. 서브 쿼리는 뉴욕의 부서에 대한 부서_id가 포함된 테이블을 반환하며 이는 기본 쿼리의 WHERE 절에서 사용됩니다.

자주 발생하는 실수

1. 서브쿼리 중첩이 올바르지 않은 경우

-- 올바른 구문
SELECT * FROM orders WHERE order_id IN (SELECT order_id FROM order_items WHERE product_id = 100);

-- 잘못된 구문 (괄호가 누락됨)
SELECT * FROM orders WHERE order_id IN SELECT order_id FROM order_items WHERE product_id = 100);

2. 상관 서브쿼리 사용이 잘못된 경우

-- 비효율적인 상관 서브쿼리
SELECT o.* FROM orders o WHERE EXISTS (SELECT 1 FROM order_items oi WHERE o.order_id = oi.order_id AND oi.product_id = 100);

-- 더 효율적인 JOIN
SELECT o.* FROM orders o JOIN order_items oi ON o.order_id = oi.order_id WHERE oi.product_id = 100;

3. EXISTS 또는 NOT EXISTS를 적절하게 사용하지 않는 경우

-- 비효율적인 방법
SELECT * FROM orders WHERE (SELECT COUNT(*) FROM order_items WHERE order_id = orders.order_id) > 0;

-- 더 효율적인 방법
SELECT * FROM orders WHERE EXISTS (SELECT 1 FROM order_items WHERE order_id = orders.order_id);

4. 집계 및 비집계 식을 혼합하여 사용하는 경우

-- 잘못된 방법
SELECT product_id, COUNT(order_id), order_id FROM order_items GROUP BY product_id;

-- 올바른 방법
SELECT product_id, COUNT(order_id) FROM order_items GROUP BY product_id;

5. 서브쿼리가 단일 행을 예상하는데 여러 행이 반환되는 경우

-- 잘못된 방법
SELECT * FROM orders WHERE order_id = (SELECT order_id FROM order_items WHERE product_id = 100);

-- 올바른 방법
SELECT * FROM orders WHERE order_id IN (SELECT order_id FROM order_items WHERE product_id = 100);

6. 조인이 더 적절한 경우에 서브쿼리를 사용하는 경우

-- 비효율적인 서브쿼리
SELECT * FROM orders WHERE order_id IN (SELECT order_id FROM order_items WHERE product_id = 100);

-- 더 효율적인 JOIN
SELECT o.* FROM orders o JOIN order_items oi ON o.order_id = oi.order_id WHERE oi.product_id = 100;

7. 모호한 열 참조

-- 잘못된 방법
SELECT * FROM orders o, order_items oi WHERE o.order_id = oi.order_id AND product_id = 100;

-- 올바른 방법 (가독성을 위해 테이블 별칭 사용)
SELECT * FROM orders o, order_items oi WHERE o.order_id = oi.order_id AND oi.product_id = 100;

8. 서로 다른 DBMS 간의 호환성 문제

-- PostgreSQL-specific 구문 (LIMIT)
SELECT * FROM orders LIMIT 10;

-- SQL Server-specific 구문 (TOP)
SELECT TOP 10 * FROM orders;

조사하면서 느끼는 것은 SQL 들어간 것들은 다 MySQL인줄 알았는데 SQL sever가 따로 있고, PostgreSQL도 다른거고.. 결국 SQL이 Structured Query Language의 앞자를 딴 것처럼 결국 하나의 언어고 C와 C+, C++처럼 각자의 스타일로 녹여냈다는 걸 알게되고 있습니다. 참 어렵네요.

SQL JOIN 절은 테이블 간의 관련 열을 기반으로 두 개 이상의 테이블에서 행을 결합하는 데 사용됩니다. SQL JOIN에는 INNER JOIN, LEFT JOIN, RIGHT JOIN 및 FULL OUTER JOIN과 같은 여러 유형이 있습니다.

JOIN의 유형은 다음과 같습니다.

• INNER JOIN: 두 테이블에서 일치하는 값을 가진 행을 반환합니다.
  
  
• LEFT JOIN(또는 LEFT OUTER JOIN)
  왼쪽 테이블의 모든 행과 오른쪽 테이블의 일치하는 행을 반환합니다. 일치하는 항목이 없으면 오른쪽 테이블의 열에 대해 NULL 값이 반환됩니다.
  
  
• RIGHT JOIN(또는 RIGHT OUTER JOIN)
  오른쪽 테이블의 모든 행과 왼쪽 테이블의 일치하는 행을 반환합니다. 일치하는 항목이 없으면 왼쪽 테이블의 열에 대해 NULL 값이 반환됩니다.
  
  
• FULL OUTER JOIN
  왼쪽 또는 오른쪽 테이블에 일치하는 항목이 있으면 모든 행을 반환합니다. 일치하는 항목이 없으면 일치하지 않는 테이블의 열에 대해 NULL 값이 반환됩니다.

다음은 JOIN 절을 사용하기 위한 기본 구문입니다.

SELECT column1, column2, ...
FROM table1
JOIN_TYPE JOIN table2
ON table1.column_name = table2.column_name;

1. INNER JOIN

SELECT employees.first_name, employees.last_name, departments.department_name
FROM employees
INNER JOIN departments
ON employees.department_id = departments.department_id;

이 쿼리는 "department_id" 열을 사용하여 "employees" 및 "departments" 테이블 간에 INNER JOIN을 수행하여 부서 이름과 함께 직원의 성과 이름을 검색합니다.

2. LEFT JOIN

SELECT employees.first_name, employees.last_name, departments.department_name
FROM employees
LEFT JOIN departments
ON employees.department_id = departments.department_id;

이 쿼리는 직원이 어떤 부서에도 할당되지 않은 경우에도 부서 이름과 함께 모든 직원의 성과 이름을 검색합니다.

3. RIGHT JOIN

SELECT employees.first_name, employees.last_name, departments.department_name
FROM employees
RIGHT JOIN departments
ON employees.department_id = departments.department_id;

이 쿼리는 부서에 직원이 없더라도 해당 부서에 속한 직원의 성과 이름과 함께 모든 부서 이름을 검색합니다.

4. FULL OUTER JOIN

FULL OUTER JOIN은 MySQL에서 지원되지 않습니다. 그러나 이를 지원하는 데이터베이스(예: PostgreSQL, SQL Server, Oracle)에서 구문은 다음과 같습니다.

SELECT employees.first_name, employees.last_name, departments.department_name
FROM employees
FULL OUTER JOIN departments
ON employees.department_id = departments.department_id;

이 쿼리는 직원이 부서에 할당되지 않았거나 부서에 직원이 없는 경우에도 모든 직원의 이름과 성을 부서 이름과 함께 검색합니다.

JOIN 절의 특정 구현은 사용 중인 DBMS(예: MySQL, PostgreSQL, SQL Server, Oracle, SQLite)에 따라 다를 수 있습니다.

CROSS JOIN과 SELF JOIN

1. CROSS JOIN

데카르트 JOIN이라고도 하는 CROSS JOIN은 첫 번째 테이블의 각 행을 두 번째 테이블의 각 행과 결합하여 두 테이블의 데카르트 곱을 생성하는 JOIN 작업 유형입니다. 테이블 JOIN에는 조건이 필요하지 않습니다. CROSS JOIN의 결과 집합에는 JOIN되는 두 테이블의 행 수를 곱한 것과 동일한 행 수가 있습니다.

1) 테이블 예시

1 번 테이블

2 번 테이블

2) 테이블1과 테이블2 사이의 CROSS JOIN

SELECT * FROM Table1 CROSS JOIN Table2;

3) Output

2. SELF JOIN


SELF JOIN은 일반 JOIN 작업이지만 단일 테이블에 적용됩니다. SELF JOIN을 수행하려면 테이블에 대한 별칭을 생성하고 이 별칭을 사용하여 JOIN 조건에서 동일한 테이블을 참조해야 합니다. SELF JOIN은 관련 열을 기반으로 동일한 테이블의 행을 결합하려는 경우에 사용됩니다.

1) 테이블 예시

2) 직원과 해당 관리자를 찾기 위한 SELF JOIN

SELECT e1.name AS Employee, e2.name AS Manager
FROM employees e1
INNER JOIN employees e2 ON e1.manager_id = e2.id;

3) Output

목차

1. 테이블(Table)이란?
2. GROUP BY
3. HAVING
4. ORDER BY
5. 테이블 관련 명령어
6. 테이블에 정보 입력하기

테이블(Table)이란?

MySQL에서의 테이블은 데이터베이스에서 데이터를 저장하는 논리적인 공간으로, 테이블은 여러 열(Column)과 행(Row)으로 이루어져 있습니다. 각 열은 특정 유형의 데이터를 저장하고, 각 행은 데이터의 인스턴스를 나타냅니다. 즉, 테이블은 데이터의 구조와 레코드를 정의하며, 데이터를 검색, 삽입, 업데이트, 삭제하는 데 사용됩니다. 테이블은 SQL 쿼리를 통해 생성, 수정, 삭제할 수 있으며, 다른 테이블과 JOIN을 사용하여 관련 데이터를 가져올 수도 있습니다.

GROUP BY

SQL에서 `GROUP BY` 절은 특정 열(들)을 기준으로 데이터를 그룹화하고, 그룹별로 집계 함수를 적용하여 결과를 반환하는 데 사용됩니다. 집계 함수에는 `SUM`, `COUNT`, `AVG`, `MIN`, `MAX` 등이 포함됩니다.

예를 들어, 다음과 같은 `sales` 테이블이 있다고 가정해 보겠습니다.

각 제품별로 총 판매량을 계산하려면 다음과 같이 `GROUP BY` 절을 사용할 수 있습니다.

SELECT product_id, SUM(quantity) as total_sales
FROM sales
GROUP BY product_id;

이 쿼리의 결과는 다음과 같습니다.

`GROUP BY` 절은 여러 열을 그룹화하는 데도 사용할 수 있습니다. 예를 들어, 제품별로 월별 판매량을 계산하려면 다음과 같이 작성할 수 있습니다.

SELECT product_id, EXTRACT(MONTH FROM sale_date) as sale_month, SUM(quantity) as total_sales
FROM sales
GROUP BY product_id, sale_month;

이 예제에서는 `EXTRACT` 함수를 사용하여 `sale_date`에서 월 정보를 추출하고, 그룹화에 사용했습니다.

HAVING

`HAVING` 절은 `GROUP BY` 절과 함께 사용되며, 그룹화된 결과에 대해 조건을 적용하여 필터링할 때 사용됩니다. 일반적으로 `HAVING` 절은 `GROUP BY` 절 다음에 위치하며, 집계 함수를 포함한 조건을 지정할 수 있습니다.

다음은 `sales` 테이블을 이용한 예시입니다.

제품별로 총 판매량이 7개 이상인 경우만 조회하려면 `GROUP BY` 절과 `HAVING` 절을 함께 사용하면 됩니다.

SELECT product_id, SUM(quantity) as total_sales
FROM sales
GROUP BY product_id
HAVING total_sales >= 7;

이 쿼리의 결과는 다음과 같습니다.

여기서 `HAVING` 절은 그룹화된 결과에서 `total_sales`가 7 이상인 것만 선택하도록 지정하고 있습니다. `HAVING` 절에 집계 함수를 직접 사용하는 것도 가능합니다.

SELECT product_id, SUM(quantity) as total_sales
FROM sales
GROUP BY product_id
HAVING SUM(quantity) >= 7;

이 예제에서도 동일한 결과가 반환됩니다.

ORDER BY

SQL의 "ORDER BY" 절은 하나 이상의 열을 기준으로 쿼리 결과를 오름차순 또는 내림차순으로 정렬하는 데 사용됩니다. 기본적으로 정렬은 오름차순으로 수행됩니다. 결과를 내림차순으로 정렬하려면 "DESC" 키워드를 사용할 수 있습니다. 예를 들어, 총 판매량이 7개 이상인 제품을 판매량 기준으로 내림차순 정렬하려면 다음과 같이 작성할 수 있습니다.

SELECT product_id, SUM(quantity) as total_sales
FROM sales
GROUP BY product_id
HAVING total_sales >= 7
ORDER BY total_sales DESC;

결과는 다음과 같습니다.

SELECT product_id, SUM(quantity) as total_sales
FROM sales
GROUP BY product_id
HAVING SUM(quantity) >= 7
ORDER BY total_sales DESC;

테이블 관련 명령어

SQL에서 테이블을 관리하는 주요 작업은 테이블 생성, 수정, 삭제입니다. 아래에서 각 작업에 대한 설명과 예시를 제공하겠습니다.

1. 테이블 생성 (CREATE TABLE):
테이블을 생성하려면 CREATE TABLE 문을 사용하고, 열 이름과 데이터 유형을 지정해야 합니다. 기본 키와 외래 키 등의 제약 조건도 추가할 수 있습니다.

예시:

CREATE TABLE employees (
    employee_id INT PRIMARY KEY,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    email VARCHAR(100) UNIQUE,
    hire_date DATE
);

2. 테이블 수정 (ALTER TABLE):
테이블을 수정하려면 ALTER TABLE 문을 사용하고, 열을 추가, 삭제 또는 수정할 수 있습니다. 제약 조건도 변경할 수 있습니다.

예시 1(열 추가):

ALTER TABLE employees
ADD phone_number VARCHAR(20);

예시 2(열 수정):

ALTER TABLE employees
MODIFY email VARCHAR(150) UNIQUE;

예시 3(열 삭제):

ALTER TABLE employees
DROP COLUMN phone_number;

3. 테이블 삭제 (DROP TABLE):
테이블을 삭제하려면 DROP TABLE 문을 사용합니다. 이 작업은 되돌릴 수 없으므로 주의하세요.

예시:

DROP TABLE employees;

이러한 명령은 데이터베이스 관리 시스템(DBMS)에서 테이블 구조를 관리할 수 있게 해줍니다. 어떤 작업을 수행할지 결정할 때에는 데이터 요구 사항과 목표를 고려해야 합니다.

테이블에 정보 입력하기

SQL에서 검색 결과를 기존 테이블에 입력하거나 새로운 테이블을 생성하며 입력하는 방법은 다음과 같습니다.

1. 기존 테이블에 검색 결과를 입력하기 (INSERT INTO SELECT):
INSERT INTO SELECT 문을 사용하여 검색 결과를 기존 테이블에 추가할 수 있습니다. 이 방법을 사용하려면 원본 테이블에서 검색된 열과 대상 테이블의 열이 일치해야 합니다.

예시:

INSERT INTO target_table (column1, column2, column3)
SELECT column1, column2, column3
FROM source_table
WHERE condition;

2. 새로운 테이블을 생성하며 검색 결과를 입력하기 (CREATE TABLE AS SELECT):
CREATE TABLE AS SELECT 문을 사용하여 검색 결과를 새 테이블에 입력할 수 있습니다. 이 작업은 원본 테이블에서 검색된 데이터를 기반으로 새로운 테이블을 생성하며, 구조와 인덱스는 복사되지 않습니다.

예시:

CREATE TABLE new_table
AS
SELECT column1, column2, column3
FROM source_table
WHERE condition;

이러한 방법을 사용하여 SQL 쿼리를 기반으로 기존 테이블에 데이터를 추가하거나 새 테이블을 생성할 수 있습니다. 어떤 방법을 사용할지는 요구 사항과 목표에 따라 결정하게 됩니다.

목차

1. range 함수 기본 사용법
2. range와 list 같이 사용하기
3. range에 수식을 넣어 사용하기
4. 자주 발생할 수 있는 실수들
5. range로 나누기 연산자(/) 사용 방법

range 함수 기본 사용법

파이썬에서 range() 함수는 연속된 숫자들을 만들어내는 데 사용되는 내장 함수입니다. range()는 주로 for 반복문과 함께 사용되어 숫자들을 반복 처리할 때 유용합니다.

range() 함수는 아래와 같은 구문을 사용합니다.

range(stop)
range(start, stop)
range(start, stop, step)

• start: (옵션) 시작하는 숫자. 기본값은 0입니다.
• stop: 반드시 지정해야 하는 값으로, 생성할 숫자 범위의 끝을 나타냅니다. 이 값은 범위에 포함되지 않습니다.
• step: (옵션) 각 숫자들 사이의 간격. 기본값은 1입니다.

예시:

# 1. 0부터 4까지의 숫자 생성
for i in range(5):
    print(i) # 결과: 0, 1, 2, 3, 4

# 2. 2부터 8까지의 숫자 생성 (8은 포함되지 않음)
for i in range(2, 8):
    print(i) # 결과: 2, 3, 4, 5, 6, 7

# 3. 2부터 15까지의 숫자 생성, 간격은 3
for i in range(2, 15, 3):
    print(i) # 결과: 2, 5, 8, 11, 14

range() 함수는 범위의 숫자를 생성할 때 지정된 조건에 따라 값을 생성하므로 메모리를 효율적으로 사용할 수 있습니다. 이는 큰 범위의 숫자를 처리할 때 유용합니다.

range와 list 같이 사용하기

파이썬에서 list()와 range() 함수를 함께 사용하면, 특정 범위의 숫자들을 포함하는 리스트를 생성할 수 있습니다. range() 함수를 사용하여 원하는 범위의 숫자를 생성한 후, list() 함수를 사용하여 이를 리스트로 변환하면 됩니다.

# 1. 0부터 4까지의 숫자를 포함하는 리스트 생성
numbers = list(range(5))
print(numbers)  # 결과: [0, 1, 2, 3, 4]

# 2. 2부터 8까지의 숫자를 포함하는 리스트 생성 (8은 포함되지 않음)
numbers = list(range(2, 8))
print(numbers)  # 결과: [2, 3, 4, 5, 6, 7]

# 3. 2부터 15까지의 숫자를 포함하는 리스트 생성, 간격은 3
numbers = list(range(2, 15, 3))
print(numbers)  # 결과: [2, 5, 8, 11, 14]

이렇게 list()와 range()를 함께 사용하면, 원하는 범위의 숫자들로 구성된 리스트를 간편하게 생성할 수 있습니다. 하지만 주의할 점은, 큰 범위의 숫자들을 리스트로 변환할 경우 메모리 사용량이 높아질 수 있다는 것입니다. 이 경우, range() 함수를 직접 사용하는 것이 메모리 효율성 측면에서 더 좋습니다.

range에 수식을 넣어 사용하기

파이썬의 range() 함수는 매개 변수에 수식을 포함할 수 있습니다. 이렇게 하면 다양한 방식으로 범위를 생성할 수 있습니다. 다음은 수식을 사용하는 몇 가지 예시입니다:

# 1. 1부터 10까지의 제곱수를 생성하는 리스트
squares = [x**2 for x in range(1, 11)]
print(squares)  # 결과: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 2. 5부터 20까지의 숫자 중 짝수만 포함하는 리스트
even_numbers = list(range(5 + (5 % 2), 21, 2))
print(even_numbers)  # 결과: [6, 8, 10, 12, 14, 16, 18, 20]

# 3. 1부터 10까지의 숫자 중 3의 배수만 포함하는 리스트
multiples_of_three = list(range(3, 11, 3))
print(multiples_of_three)  # 결과: [3, 6, 9]

# 4. 10부터 50까지의 숫자 중 5씩 증가하는 리스트
increment_by_five = list(range(10, 51, 5))
print(increment_by_five)  # 결과: [10, 15, 20, 25, 30, 35, 40, 45, 50]

이러한 방식으로 range() 함수에 수식을 포함시켜 다양한 범위의 숫자들로 구성된 리스트를 생성할 수 있습니다. 이렇게 유연하게 사용하면 복잡한 조건과 범위를 만족하는 숫자 리스트를 간단하게 구성할 수 있습니다.

자주 발생할 수 있는 실수들

방금 제시한 코드를 작성하면서 발생할 수 있는 일반적인 실수들은 다음과 같습니다:

1. 오프 바이 원 (Off-by-one) 오류: range() 함수의 끝 값은 범위에 포함되지 않기 때문에, 끝 값을 원하는 마지막 숫자보다 1만큼 크게 설정해야 합니다. 이 점을 간과하면 원하는 결과를 얻지 못할 수 있습니다.

# 잘못된 예시
wrong_range = list(range(1, 10))  # 결과: [1, 2, 3, 4, 5, 6, 7, 8, 9] - 10이 빠짐

# 올바른 예시
correct_range = list(range(1, 11))  # 결과: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 또는
correct_range = list(range(1, 10 + 1))  # 결과: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2. 잘못된 시작값: 시작값을 잘못 설정하면 원하지 않는 결과를 얻을 수 있습니다. 시작값을 설정할 때 주의 깊게 검토해야합니다.

# 잘못된 예시
wrong_step = list(range(1, 11, 2))  # 결과: [1, 3, 5, 7, 9] - 짝수가 빠짐

# 올바른 예시
correct_step = list(range(2, 11, 2))  # 결과: [2, 4, 6, 8, 10]

3. 수식 오류: range() 함수의 매개 변수에 사용되는 수식이 잘못되면, 예상치 못한 결과를 얻을 수 있습니다. 수식을 사용할 때 계산이 올바르게 수행되는지 확인해야합니다.

# 잘못된 예시
wrong_expression = list(range(5 + (5 % 3), 21, 2))  # 결과: [7, 9, 11, 13, 15, 17, 19] - 시작점이 6이 아닌 7부터 시작

# 올바른 예시
correct_expression = list(range(5 + (5 % 2), 21, 2))  # 결과: [6, 8, 10, 12, 14, 16, 18, 20]

위와 같은 실수를 피하기 위해 코드를 작성할 때 주의를 기울이고, 범위와 조건을 정확하게 확인해야합니다. 또한, 코드를 실행하여 결과를 검증하고, 필요한 경우 수정해야합니다.

range로 나누기 연산자(/) 사용 방법

파이썬에서 나누기 연산자(/)는 두 숫자를 나누는 연산을 수행합니다. 그러나 range() 함수에 직접 사용할 수는 없습니다. 그 대신, range() 함수의 시작 값, 끝 값, 또는 증가값에 수식을 사용하여 나눗셈 연산을 적용할 수 있습니다.

예를 들어, 1부터 20까지의 숫자 중에서 2로 나누어 떨어지는 숫자들만 생성하려면 다음과 같이 range() 함수와 나누기 연산자를 사용할 수 있습니다.

even_numbers = list(range(2, 21, 2))
print(even_numbers)  # 결과: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

위의 코드에서는 range() 함수의 시작 값이 2, 끝 값이 21, 그리고 증가값이 2로 설정되어 있습니다. 이렇게 하면 2로 나누어 떨어지는 짝수만 생성되는 범위가 만들어집니다.

또 다른 예로, 1부터 10까지의 숫자를 반으로 나누어 출력하려면 다음과 같이 할 수 있습니다.

half_numbers = [x / 2 for x in range(1, 11)]
print(half_numbers)  # 결과: [0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]

하지만 정수만 출력하고 싶다면 이 연산자(//)를 사용합니다. 이 연산자는 두 숫자를 나눈 후 몫을 반환합니다. 그러나 위 예시와 마찬가지로 range() 함수에 직접 사용할 수는 없습니다. 따라서 다음과 같이 사용합니다.

예를 들어, 1부터 10까지의 숫자를 2로 나눈 몫을 구하려면 다음과 같이 할 수 있습니다.

integer_division = [x // 2 for x in range(1, 11)]
print(integer_division)  # 결과: [0, 1, 1, 2, 2, 3, 3, 4, 4, 5]

목차

1. 키-값 쌍이란?
2. 딕셔너리(Dictionary)
3. 자주 발생하는 실수 유형

키-값 쌍이란?

Python 딕셔너리에서 키와 값은 키-값 쌍을 형성하는 두 가지 주요 구성 요소입니다.

키(key)

• 키는 딕셔너리에 저장된 해당 값을 참조하는 데 사용되는 고유 식별자입니다.
• 키는 일반적으로 문자열이나 숫자이지만 튜플(불변 요소만 포함)과 같은 다른 불변 데이터 유형일 수도 있습니다.
• 딕셔너리의 각 키는 고유해야 합니다. 기존 키에 새 값을 할당하면 이전 값이 대체됩니다.

값(value)

• 값은 딕셔너리의 해당 키와 관련된 데이터입니다.
• 값은 문자열, 숫자, 목록, 튜플 또는 기타 딕셔너리과 같은 모든 데이터 유형이 될 수 있습니다.
• 값은 딕셔너리에서 중복될 수 있습니다. 여러 키가 동일한 값을 가질 수 있습니다.

다음은 키와 값이 있는 Python 딕셔너리의 예입니다.

person = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "job": "Software Engineer"
}

이 예에서 키는 "name", "age", "city" 및 "job"이고 값은 "Alice", 30, "New York" 및 "Software Engineer"입니다.

딕셔너리(Dictionary)

Python 딕셔너리는 각 키가 고유해야 하는 키-값 쌍의 변경 가능하고 정렬되지 않은 모음입니다. 딕셔너리는 다른 프로그래밍 언어에서 연관 배열, 해시 맵 또는 해시 테이블이라고도 합니다. 이들은 Python에서 해시 테이블로 구현되어 키를 기반으로 요소에 대한 빠른 액세스, 삽입 및 삭제를 제공합니다.

Python 딕셔너리을 선언하려면 중괄호 {}를 사용하고 콜론을 사용하여 키-값 쌍을 구분합니다. 특정 키와 관련된 값에 액세스하려면 대괄호 []를 사용할 수 있습니다. 예를 들면 다음과 같습니다.예를 들면 다음과 같습니다.

# Declare a 딕셔너리
book = {
    "title": "The Catcher in the Rye",
    "author": "J.D. Salinger",
    "year": 1951,
    "genre": "Fiction"
}

# Accessing a value by key
print(book["title"])  # Output: The Catcher in the Rye

이 예에서 book 딕셔너리에는 "title", "author", "year" 및 "genre"라는 4개의 키-값 쌍이 있습니다. 키와 관련된 값에 액세스하려면 print() 명령문에 표시된 대로 대괄호 []와 키를 사용해야합니다.

딕셔너리에 대한 몇 가지 일반적인 작업은 다음과 같습니다.

1. 딕셔너리 생성

# 딕셔너리 생성
person = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

# 키를 이용한 값 접근
print(person["name"])  # Output: John

2. 요소 추가 또는 업데이트

person["country"] = "USA"  # 새로운 키-값 쌍 추가
person["age"] = 31         # "age" 키에 연결된 값을 업데이트

3. 키-값 쌍 제거

del person["age"]  # "age" 키에 연결된 키-값 쌍 삭제

4. 딕셔너리에 키가 존재하는지 확인

if "name" in person:
    print("딕셔너리에 'name' 키가 존재합니다.")

5. 딕셔너리 반복

# 키를 이용한 반복(iterate)
for key in person:
    print(key)

# 값에 대한 반복(iterate)
for value in person.values():
    print(value)

# 키-값 쌍에 대한 반복(iterate)
for key, value in person.items():
    print(f"{key}: {value}")

6. 딕셔너리 이해
Comprehension을 나열하는 구문과 유사하지만 중괄호 {}를 사용하는 딕셔너리 이해를 사용하여 딕셔너리을 만들 수 있습니다.

squares = {x: x**2 for x in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

딕셔너리는 Python의 강력하고 다양한 데이터 구조로, 키를 기반으로 데이터를 구성하고 액세스하는 효율적인 방법을 제공합니다.

7. 딕셔너리과 함께 get() 함수를 사용하는 예

# 딕셔너리 정의
student_grades = {
    "John": 85,
    "Sarah": 90,
    "Anna": 78,
    "Tom": 92
}

# get() 함수를 사용하여 키로 값을 가져옵니다.
johns_grade = student_grades.get("John")
print("John's grade:", johns_grade)  # 출력: John's grade: 85

# get() 함수를 사용하여 존재하지 않는 키의 경우 기본값을 설정합니다.
non_existent_key = "Michael"
michaels_grade = student_grades.get("Michael", "Not found")
print("Michael's grade:", michaels_grade)  # 출력: Michael's grade: Not found

이 예에서는 학생 이름을 키로, 각 성적을 값으로 포함하는 'student_grades'라는 딕셔너리을 정의합니다. 그런 다음 get() 함수를 사용하여 "John"과 "Michael"의 등급에 액세스합니다. "Michael"이 딕셔너리에 없기 때문에 get() 함수는 기본값 "찾을 수 없음"을 반환합니다.

자주 발생하는 실수 유형

다음은 Python 딕셔너리 코드를 작성할 때 발생하는 몇 가지 일반적인 실수와 이를 수정하는 방법입니다.


1. 변경 가능한 데이터 유형을 키로 사용

문제: 목록과 같은 변경 가능한 데이터 유형을 딕셔너리의 키로 사용하면 TypeError가 발생합니다.
해결 방법: 문자열, 숫자 또는 튜플(불변 요소 포함)과 같은 불변 데이터 유형을 키로 사용합니다.

# Incorrect
my_dict = {['a', 'b']: 1}

# Correct
my_dict = {('a', 'b'): 1}

2. 요소 액세스에 잘못된 구문 사용

문제: dict[key] 대신 dict.key와 같이 잘못된 구문을 사용하여 딕셔너리의 요소에 액세스하려고 합니다.
해결 방법: 올바른 구문 dict[key]를 사용하여 딕셔너리의 요소에 액세스해야합니다.

# Incorrect
value = my_dict.key

# Correct
value = my_dict['key']

3. 존재하지 않는 키에 액세스

문제: 딕셔너리에 없는 키에 액세스하려고 하면 KeyError가 발생합니다.
해결 방법: 키를 찾을 수 없는 경우 기본값을 반환하는 get() 메서드를 사용하거나 in과 함께 조건문을 사용하여 키의 존재를 확인합니다.

# Incorrect
value = my_dict['non_existent_key']

# Correct
value = my_dict.get('non_existent_key', 'default_value')

# or
if 'non_existent_key' in my_dict:
    value = my_dict['non_existent_key']
else:
    value = 'default_value'

4. 잘못된 요소 추가 또는 업데이트

문제: dict[key] = value 대신 dict.key = value와 같이 잘못된 구문을 사용하여 딕셔너리에 요소를 추가하거나 업데이트하려고 합니다.
해결 방법: 올바른 구문인 dict[key] = value를 사용하여 딕셔너리에 요소를 추가하거나 업데이트합니다.

# Incorrect
my_dict.key = 'value'

# Correct
my_dict['key'] = 'value'

5. 적절한 들여쓰기를 사용하지 않음

문제: 코드 들여쓰기가 잘못되어 구문 오류 또는 예기치 않은 동작이 발생할 수 있습니다.
해결 방법: 각 들여쓰기 수준에 대해 4개의 공백 또는 단일 탭을 사용하여 Python의 적절한 들여쓰기 규칙을 따라야합니다.


이러한 일반적인 실수와 해결 방법을 알고 있으면 오류를 방지하고 Python에서 보다 효율적이고 정확한 딕셔너리 코드를 작성할 수 있습니다.