
| 함수 | 설명 |
|---|---|
| UPPER(문자열) | 괄호 안 문자 데이터를 모두 대문자로 변환하여 반환 |
| LOWER(문자열) | 괄호 안 문자 대이터를 모두 소문자로 변환하여 반환 |
| INITCAP(문자열) | 괄호 안 문자 데이터 중 첫 글자는 대문자로, 나머지 문자를 소문자로 변환 후 반환 |
SELECT ENAME, UPER(ENAME), LOWER(ENAME), INITCAP(ENAME)
FROM EMP;
// LIKE 연산자를 와일드 카드와 함께 사용 가능
SELECT *
FROM 게시판테이블
WHERE 게시판 제목 열 LIKE '%Oracle%'
OR 게시판 제목 열 LIKE '%Oracle%';
위의 예시의 경우, 검색하는 사람이 대소문자를 섞어서 검색할 경우, 원하는 결과 값을 얻기 어렵다.
따라서 이 경우에 조건식 양쪽 항목의 문자열을 모두 대문자나 소문자로 바꿔서 비교한다면, 실제 검색어의 대소문자 여부와 상관 없이 검색 단어와 일치한 문자열을 포함한 데이터를 찾을 수 있다.
UPPER 함수로 문자열 비교하기(사원 이름이 SCOTT인 데이터 찾기)
SELECT *
FROM EMP
WHERE UPPER(ENAME) = UPPER('scott');
SELECT *
FROM EMP
WHERE UPPER(ENAME) LIKE '%scott%';
SELECT ENAME, LENGTH(ENAME)
FROM EMP;
SELECT ENAME, LENGTH(ENAME)
FROM EMP
WHERE LENGTH(ENAME) >= 5;
| 함수 | 설명 |
|---|---|
| SUBSTR(문자열 데이터, 시작 위치, 추출길이) | 문자열 데이터의 시작 위치부터 추출 길이 만큼 추출한다. 시작 위치가 음수일 경우 마지막 위치부터 거슬러 올라간 위치에서 다시 오른쪽으로 시작한다. |
| SUBSTR(문자열 데이터, 시작 위치) | 문자열 데이터의 시작 위치부터 문자열 데이터 끝까지 추출한다. 시작 위치가 음수일 경우, 마지막 위치부터 거슬러 올라간 위치에서 끝까지 추출한다. |
SELECT JOB
SUBSRT(JOB, 1, 2), // 1~2
SUBSTR(JOB, 3, 2), //3~4
SUBSTR(JOB, 5) // 5~끝까지
FROM EMP;
SELECT JOB
SUBSRT(JOB, -LENGTH(JOB)), 1~끝까지
SUBSTR(JOB, -LENGTH(JOB), 2), //1~2
SUBSTR(JOB, -3) // 뒤에서 3번째 ~ 끝까지
FROM EMP;
INSTR([대상 문자열 데이터(필수)],
[위치를 찾으려는 부분 문자(필수)],
[위치 찾기를 시작할 대상 문자열 데이터 위치(선택, 기본값은 1)],
[시작 위치에서 찾으려는 문자가 몇 번째로 등장하는지 지정(선택, 기본값은 1)])
SELECT INSTR('HELLO, ORACLE!', 'L') AS INSTR_1, //3, 처음부터 검색
INSTR('HELLO, ORACLE!', 'L', 5) AS INSTR_2, //12
INSTR('HELLO, ORACLE!', 'L', 2, 2) AS INSTR_3 //4
FROM DUAL;
// INSTR함수로 사원 이름에 문자 S가 있는 행 구하기
SELECT *
FROM EMP
WHERE INSTR(ENAME, 'S') > 0;
// LIKE 연산자로 사원 이름에 문자 S가 있는 행 구하기
SELECT *
FROM EMP
WHERE ENAME LIKE '%S%';
REPLACE([문자열 데이터 또는 열 이름(필수)], [찾는 문자(필수)], [대체할 문자(선택)])
SELECT '010-1234-5678' AS REPLACE_BEFORE,
// -가 공백으로 교체되어 출력
REPLACE('010-1234-5678', '-', ' ') AS REPLACE_1,
// -가 아예 삭제되어 숫자가 붙어서 나타남
REPLACE('010-1234-5678', '-') AS REPLACE_2
FROM DUAL;
LPAD([문자열 데이터 또는 열이름(필수)], [데이터의 자릿수(필수)], [빈 공간에 채울 문자(선택)])
RPAD([문자열 데이터 또는 열이름(필수)], [데이터의 자릿수(필수)], [빈 공간에 채울 문자(선택)])
SELECT 'Oracle',
LPAD('Oracle', 10, '#') AS LPAD_1,
RPAD('Oracle', 10, '*') AS RPAD_1,
LPAD('Oracle', 10) AS LPAD_2,
RPAD('Oracle', 10) AS RPAD_2
FROM DUAL;

SELECT
RPAD('971225-', 14, '*') AS RPAD_JMNO,
RPAD('010-1234-', 13, '*') AS RPAD_PHONE
FROM DUAL;

SELECT CONCAT(EMPNO, ENAME),
CONCAT(EMPNO, CONCAT(':', ENAME))
FROM EMP
WHERE ENAME = 'SCOTT';
SELECT EMPNO || ENAME,
EMPNO || ':' || ENAME
FROM ...
TRIM([삭제 옵션(선택)] [삭제할 문자(선택)]
FROM [원본 문자열 데이터(필수)])
SELECT '[' || TRIM('_' FROM '_ _Oracle_ _') || ']' AS TRIM,
'[' || TRIM(LEADING '_' FROM '_ _Oracle_ _') || ']' AS TRIM_LEADING,
'[' || TRIM(TRAILING '_' FROM '_ _Oracle_ _') || ']' AS TRIM_TRAILING,
'[' || TRIM(BOTH '_' FROM '_ _Oracle_ _') || ']' AS TRIM_BOTH
FROM DUAL;

SELECT '[' || TRIM('_' FROM '_ _Oracle_ _') || ']' AS TRIM,
'[' || TRIM(LEADING '_' FROM '_ _Oracle_ _') || ']' AS TRIM_LEADING,
'[' || TRIM(TRAILING '_' FROM '_ _Oracle_ _') || ']' AS TRIM_TRAILING,
'[' || TRIM(BOTH '_' FROM '_ _Oracle_ _') || ']' AS TRIM_BOTH
FROM DUAL;

LTRIM([원본 문자열 데이터(필수)], [삭제할 문자 집합(선택)])
RTRIM([원본 문자열 데이터(필수)], [삭제할 문자 집합(선택)])
SELECT '[' || TRIM(' _Oracle_ ') || ']' AS TRIM,
'[' || LTRIM(' _Oracle_ ') || ']' AS LTRIM,
'[' || LTRIM('<_Oracle_>', '_<') || ']' AS LTRIM2,
'[' || LTRIM('<_<_Oracle_>', '_<') || ']' AS LTRIM3,
'[' || RTRIM(' _Oracle_ ') || ']' AS RTRIM,
'[' || RTRIM('<_Oracle_>', '>_') || ']' AS RTRIM_2
FROM DUAL

| 함수 | 설명 |
|---|---|
| ROUND | 지정된 숫자의 특정 위치에서 반올림한 값을 반환 |
| TRUNC | 지정된 숫자의 특정 위치에서 버림한 값을 반환 |
| CEIL | 지정된 숫자보다 큰 정수 중 가장 작은 정수를 반환 |
| FLOOR | 지정된 숫자보다 작은 정수 중 가장 큰 정수를 반환 |
| MOD | 지정된 숫자를 나눈 나머지 값을 반환 |
ROUND([숫자(필수)], [반올림 위치(선택)])
SELECT ROUND(1234,5678) AS ROUND,
ROUND(1234.5678, 0) AS ROUND_0,
ROUND(1234.5678, 1) AS ROUND_1, // 소수점 둘째자리에서 반올림
ROUND(1234.5678, 2) AS ROUND_2,
ROUND(1234.5678, -1) AS ROUND_MINUS1, // 실수 첫째자리에서 반올림
ROUND(1234.5678, -2) AS ROUND_MINUS2
FROM DUAL;

| 수 | 1 | 2 | 3 | 4 | . | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|---|
| 인덱스 | -4 | -3 | -2 | -1 | . | 0 | 1 | 2 | 3 | 4 |
TRUNC([숫자(필수)], [버림 위치(선택)])
SELECT TRUNC(1234.5678) AS TRUNC,
TRUNC(1234.5678, 0) AS TRUNC_0,
TRUNC(1234.5678, 1) AS TRUNC_1,
TRUNC(1234.5678, 2) AS TRUNC_2,
TRUNC(1234.5678, -1) AS TRUNC_MINUS1,
TRUNC(1234.5678, -2) AS TRUNC_MINUS2
FROM DUAL;
CEIL([숫자(필수)]);
FLOOR([숫자(필수)]);
SELECT CEIL(3.14),
FLOOR(3.14),
CEIL(-3.14),
FLOOR(-3.14)
FROM DUAL;

MOD([나눗셈 될 숫자(필수)], [나눌 숫자(필수)]);
SELECT MOD(15, 6),
MOD(10, 2),
MOD(11, 2)
FROM DUAL;

| 연산 | 설명 |
|---|---|
| 날짜 데이터 + 숫자 | 날짜 데이터보다 숫자만큼 일수 이후의 날짜 |
| 날짜 데이터 - 숫자 | 날짜 데이터보다 숫자만큼의 일수 이전의 날짜 |
| 날짜 데이터 - 날짜 데이터 | 두 날짜 데티어 간의 일수 차이 |
| 날짜 데이터 + 날짜 데이터 | 연산 불가, 지원하지 않음 |
SELECT SYSDATE AS NOW,
SYSDATE - 1 AS YESTERDAY,
SYSDATE +1 AS TOMORROW
FROM DUAL;

ADD_MONTHS([날짜 데이터(필수)], [더할 개월수(정수)(필수)]
SELECT SYSDATE,
ADD_MONTHS(SYSDATE, 3)
FROM DUAL;

SELECT EMPNO, ENAME, HIREDATE,
ADD_MONTHS(HIREDATE, 120) AS WORK10YEAR
FROM EMP;

SELECT EMPNO, ENAME, HIREDATE, SYSDATE
FROM EMP
WHERE ADD_MONTHS(HIREDATE, 36*12) > SYSDATE;

MONTHS_BETWEEN([날짜 데이터(필수)], [날짜 데이터2(필수)])
SELECT EMPNO, ENAME, HIREDATE, SYSDATE,
MONTHS_BETWEEN(HIREDATE, SYSDATE) AS MONTH1,
MONTHS_BETWEEN(SYSDATE, HIREDATE) AS MONTH2,
TRUNC(MONTHS_BETWEEN(SYSDATE, HIREDATE)) AS MONTH3
FROM EMP;

NEXT_DAY([날짜 데이터(필수)], [요알 문자(필수)])
LAST_DAY([날짜 데이터(필수)])
SELECT SYSDATE,
NEXT_DAY(SYSDATE, '월요일'),
LAST_DAY(SYSDATE)
FROM DUAL;

| 입력 데이터 종류 | 사용 방식 |
|---|---|
| 숫자 데이터 | ROUND([숫자(필수)], [반올림 위치]) |
| TRUNC([숫자(필수)], [버림 위치] | |
| 날짜 데이터 | ROUND([날짜데이터(필수)], [반올림 기준 포맷]) |
| TRUNC([날짜데이터(필수)], [버림 기준 포맷]) |
SELECT SYSDATE,
ROUND(SYSDATE, 'CC') AS FORMAT_CC,
ROUND(SYSDATE, 'YYYY') AS FORMAT_YYYY,
ROUND(SYSDATE, 'Q') AS FORMAT_Q,
ROUND(SYSDATE, 'DDD') AS FORMAT_DDD,
ROUND(SYSDATE, 'HH') AS FORMAT_HH
FROM DUAL;
SELECT SYSDATE,
TRUNC(SYSDATE, 'CC') AS FORMAT_CC,
TRUNC(SYSDATE, 'YYYY') AS FORMAT_YYYY,
TRUNC(SYSDATE, 'Q') AS FORMAT_Q,
TRUNC(SYSDATE, 'DDD') AS FORMAT_DDD,
TRUNC(SYSDATE, 'HH') AS FORMAT_HH
FROM DUAL;
SELECT EMPNO, ENAME, EMPNO + '500'
FROM EMP
WHERE ENAME = 'SCOTT';

SELECT 'ABC' + EMPNO, EMPNO
FROM EMP
WHERE ENAME = 'SCOTT';

| 종류 | 설명 |
|---|---|
| TO_CHAR | 숫자 또는 날짜 데이터 -> 문자 데이터 |
| TO_NUMBER | 문자 데이터 -> 숫자 데이터 |
| TO_DATE | 문자 데이터 -> 날짜 데이터 |

TO_CHAR([날짜데이터(필수)], '[출력되기 원하는 문자 형태(필수)]')
SELECT TO_CHAR(SYSDATE, 'YYYY/MM/DD HH24:MI:SS')
AS CURRENT_TIME
FROM DUAL;

SELECT SYSDATE,
TO_CHAR(SYSDATE, 'MM') AS MM,
TO_CHAR(SYSDATE, 'MON') AS MON,
TO_CHAR(SYSDATE, 'MONTH') AS MONTH,
TO_CHAR(SYSDATE, 'DD') AS DD,
TO_CHAR(SYSDATE, 'DY') AS DY,
TO_CHAR(SYSDATE, 'DAY') AS DAY
FROM DUAL;

TO_CHAR([날짜 데이터(필수)],
'[출력되길 원하는 문자 형태(필수)]',
'NLS_DATE_LANGUAGE = language'(선택))
SELECT SYSDATE,
TO_CHAR(SYSDATE, 'MON',
'NLS_DATE_LANGUAGE = KOREAN') AS MON_KOR,
TO_CHAR(SYSDATE, 'MON',
'NLS_DATE_LANGUAGE = JAPANESE') AS JAPAN,
TO_CHAR(SYSDATE, 'MON',
'NLS_DATE_LANGUAGE = ENGLISH') AS ENGLISH,
TO_CHAR(SYSDATE, 'MONTH',
'NLS_DATE_LANGUAGE = KOREAN') AS MON_KOR,
TO_CHAR(SYSDATE, 'MONTH',
'NLS_DATE_LANGUAGE = JAPANESE') AS JAPAN,
TO_CHAR(SYSDATE, 'MONTH',
'NLS_DATE_LANGUAGE = ENGLISH') AS ENGLISH
FROM DUAL;

SELECT SYSDATE,
TO_CHAR(SYSDATE, 'HH24:MI:SS') AS HH24MISS,
TO_CHAR(SYSDATE, 'HH12:MI:SS AM') AS HHMISS_AM,
TO_CHAR(SYSDATE, 'HH:MI:SS P.M.') AS HHMISS_PM
FROM DUAL;

SELECT SAL,
TO_CHAR(SAL, '$999,999') AS SAL_$, //9는 숫자 한자리
TO_CHAR(SAL, 'L999,999') AS SAL_L,
TO_CHAR(SAL, '999,999.00') AS SAL_1,
TO_CHAR(SAL, '000,999,999.00') AS SAL_2,
TO_CHAR(SAL, '000999999.99') AS SAL_3,
TO_CHAR(SAL, '999,999,00') AS SAL_4
FROM EMP;
TO_NUMBER('[문자열 데이터(필수)]', [인식될 숫자 형태(필수)]')
SELECT TO_NUMBER('1,300', '999,999') -
TO_NUMBER('1,500', '999,999') AS ANS
FROM DUAL;

TO_DATE9('[문자열 데이터(필수)]', '[인식돌 날짜형태(필수)]')
SELECT TO_DATE('2022-07-19', 'YYYY-MM-DD') AS TODATE1,
TO_DATE('20220719', 'YYYY-MM-DD') AS TODATE2
FROM DUAL;

SELECT * FROM EMP
WHERE TO_DATE('1981/06/01', 'YYYY-MM-DD') < HIREDATE;

NVL([NULL인지 여부를 검사할 데이터 또는 열(필수)],
[앞의 데이터가 NULL일 경우 반환할 데이터](필수))
SELECT EMPNO, ENAME, SAL, COMM, SAL+COMM,
NVL(COMM, 0), SAL+NVL(COMM, 0)
FROM EMP;

NVL2([NULL인지 여부를 검사할 데이터 또는 열(필수)],
[앞 데이터가 NULL이 아닐 경우 반환할 데이터 또는 계산식(필수)],
[앞 데이터가 NULL일 경우 반환할 데이터 또는 계산식(필수)])
SELECT EMPNO, ENAME, COMM,
NVL2(COMM, 'O', 'X') AS OX,
NVL2(COMM, SAL*12+COMM, SAL*12) AS ANNUAL
FROM EMP;

D=DECODE([검사 대상이 될 열 또는 데이터 연산이나, 함수의 결과],
[조건1], [데이터가 조건1과 일치할 때 반환할 결과],
[조건2], [데이터가 조건2와 일치할 때 반환할 결과],
...
[조건n], [데이터가 조건n와 일치할 때 반환할 결과],
[위 조건1~조건n과 일치한 경우가 없을 때 반환할 결과])
SELECT EMPNO, ENAME, JOB, SAL,
DECODE(JOB,
'MANAGER', SAL*1.1,
'SALESMAN', SAL*1.05,
'ANALYST', SAL,
SAL*1.03) AS UPSAL
FROM EMP;

CASE [검사 대상이 될 열 또는 데이터, 연산이나 함수의 결과(선택)]
WHEN [조건1] THEN [조건1의 결과 값이 TRUE일 때, 반환할 결과]
WHEN [조건2] THEN [조건2의 결과 값이 TRUE일 때, 반환할 결과]
...
WHEN [조건n] THEN [조건n의 결과 값이 TRUE일 때, 반환할 결과]
ELSE [위 조건1~n과 일치하는 경구가 없을 때 반환할 결과]
END
SELECT EMPNO, ENAME, JOB, SAL,
CASE JOB
WHEN 'MANAGER' THEN SAL*1.1
WHEN 'SALESMAN' THEN SAL*1.05
WHEN 'ANALYST' THEN SAL
ELSE SAL*1.03
END AS UPSAL
FROM EMP;

SELECT EMPNO, ENAME, COMM,
CASE
WHEN COMM IS NULL THEN '해당사항 없음'
WHEN COMM = 0 THEN '수당 없음'
WHEN COMM > 0 THEN '수당 : ' || COMM
END AS COMM_TEXT
FROM EMP;

SELECT EMPNO, RPAD(SUBSTR(EMPNO, 1, 2), 4, '*')
AS MASKING_EMPNO,
ENAME, RPAD(SUBSTR(ENAME, 1, 1), 5, '*')
AS MAKING_ENAME
FROM EMP;

SELECT EMPNO, ENAME, SAL,
TRUNC(SAL/21.5, 2) AS DAY_PAY,
ROUND(SAL/21.5/8, 1) AS TIME_PAY
FROM EMP;

SELECT EMPNO, ENAME, HIREDATE,
TO_CHAR(NEXT_DAY(ADD_MONTHS(HIREDATE, 3), '월요일'),
'YYYY-MM-DD') AS R_JOB,
NVL(TO_CHAR(COMM), 'N/A') AS COMM
FROM EMP;
--NVL은 두 인자 값이 서로 같은 데이터 타입이어야 하는듯

SELECT EMPNO, ENAME, MGR,
CASE
WHEN TO_CHAR(MGR) IS NULL THEN '0000'
WHEN SUBSTR(TO_CHAR(MGR), 1, 2) = '75' THEN '5555'
WHEN SUBSTR(TO_CHAR(MGR), 1, 2) = '76' THEN '6666'
WHEN SUBSTR(TO_CHAR(MGR), 1, 2) = '77' THEN '7777'
WHEN SUBSTR(TO_CHAR(MGR), 1, 2) = '78' THEN '8888'
ELSE TO_CHAR(MGR)
END AS CHG_MGR
FROM EMP;
SELECT ANIMAL_ID FROM ANIMAL_INS
WHERE NAME IS NULL;
SELECT ANIMAL_ID
FROM ANIMAL_INS
WHERE NAME IS NOT NULL
ORDER BY ANIMAL_ID;
SELECT ANIMAL_TYPE, NVL(NAME, 'No name'), SEX_UPON_INTAKE
FROM ANIMAL_INS
ORDER BY ANIMAL_ID;