Untitled_Blue

[Spring] DI에 대한 이해

Untitled_Blue — Tue, 1 Oct 2024 22:03:44 +0900

안녕하세요. 이번 글은 DI (의존성 주입)에 대한 설명입니다.

- 의존성 주입 (DI, Dependency Injection) 이란?

외부에서 객체를 직접 주입하는 방식
객체 간의 느슨한 결합을 제공하며 이를 통해 유지보수가 용이하도록 지원
코드의 재사용률을 증가시키며 객체를 개발자가 아닌 프레임워크에서 생성하도록 지원
의존성 주입하는 방법은 생성자 주입, 필드 주입, 빈 관리, setter 주입이 있음.

- 의존성 주입은 왜 필요한가?

public class VGA {
    public void mStart() {
        System.out.println("VGA Start");
    }
}

//*******************************************************

public class IntelARC extends VGA {
    @Override
    public void mStart() {
        System.out.println("VGA IntelARC Boot !");
    }
}

//*******************************************************

public class Nvidia extends VGA {
    @Override
    public void mStart() {
        System.out.println("VGA Nvidia Boot !");
    }
}

public class SecondComputer {
    private VGA vga;

    public SecondComputer() {
        this.vga = new Nvidia(); // 객체를 직접 주입 => 강한 결합
    }

    public void boot() {
        System.out.println("Computer2 Boot !");
        vga.mStart();
    }
}

// *******************************************************************

public class ThirdComputer {
    private VGA vga = new IntelARC();

    public void boot() {
        System.out.println("Computer3 Boot !");
        vga.mStart();
    }
}

public class Main {
    public static void main(String[] args) {
        // DI 미사용 => 여러 개 이상이면 유지보수 시간 및 비용 증가
        SecondComputer computer2 = new SecondComputer();
        computer2.boot();

        ThirdComputer computer3 = new ThirdComputer();
        computer3.boot();
    }
}

예를 들어 프로그래밍 기준으로 컴퓨터 안에 그래픽카드를 설치해야 하는 상황에서 그래픽카드는 엔디비아와 인텔아크 사의 제품이 있다고 가정해보자. 이때 컴퓨터는 두 개가 있는데 각각의 컴퓨터에 직접적으로 각각의 다른 그래픽카드를 설치(주입)했다. 이렇게 되면 컴퓨터라는 객체는 그래픽카드라는 객체에 의존 중인 것이다. 이렇게 되면 추후 그래픽카드를 변경할 때 각각의 컴퓨터에 가서 그래픽카드라는 객체를 변경해줘야 한다. 이렇게 되면 시간과 비용 소요가 크기 때문에 유지보수 면에서도 용이하지 않다.

DI를 통한 결합도 저하시킨 코드 [코드가 많은 관계로 확장해서 보는 것을 권장한다.]

public class Main {
    public static void main(String[] args) {
        VGA vga = null;
        
        vga = new IntelARC();
        FirstComputer computer1 = new FirstComputer(vga);
        computer1.boot();

        vga = new Nvidia();
        SecondComputer computer2 = new SecondComputer(vga);
        computer2.boot();

        vga = new Radeon();
        ThirdComputer computer3 = new ThirdComputer(vga);
        computer3.boot();
    }
}

상단과 같이 각각의 컴퓨터에 그래픽카드라는 객체 간의 결합도를 저하시켰다. 이렇게 되면 각각의 객체에 대한 의존성 주입이 가능하게 되면서 한 곳에서 객체 간의 관계를 상대적으로 쉽게 설정할 수 있으며 유지보수에 용이하게 된다.

- 의존성 주입 방법 1 : 생성자 주입

@Controller
public class HomeController {
	private final TestService testService;
	
	@Autowired
	public HomeController(TestService testService) {
		this.testService = testService;
	}
}

생성자를 통한 의존성 주입받는 방식이며 스프링에서도 공식적으로 해당 방법 권장하고 있음
객체의 불변성을 통한 NullPointerException 발생 방지 가능 (생성자는 1회에 한해 호출 가능하기 때문)
Spring 4.3 부터는 @Autowired 어노테이션 생략 가능
순환 참조 에러 방지 가능 (StackOverFlow : 서로가 서로를 메서드를 통해 참조 내지 바라보는 방식으로 인한 에러)
SOLID 내 단일 책임 원칙 보장 가능

- 의존성 주입 방법 2 : 필드 주입

@Controller
public class HomeController {
	@Autowired
	private TestService testService;
}

별도의 생성자 없이 직관적으로 필드만으로 의존성 주입하는 방식
생성자 주입에 비하면 상대적으로 간결한 점이 특징
final 키워드 사용 불가하며 의존 관계 파악이 어렵고 불변성이 보장되지 않는만큼 객체 변화가 쉬움
SOLID 내 단일 책임 원칙에 위배됨
NullPointerException, StackOverFlow 에러 발생 가능성 높음

- 의존성 주입 방법 3 : 수정자 주입

@Controller
public class HomeController {
	private TestService testService;
	
	@Autowired
	public void setTestService(TestService testService) {
		this.testService = testService;
	}
}

setter를 통한 의존성 주입하는 방식
final 키워드를 사용할 수 없는 만큼 불변성이 보장되지 않음
NullPointerException 에러 발생 가능성 있음

- 의존성 주입 방법 4 : 빈 관리

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">
	
	<bean id="testServiceimpl" class="com.spf.study.TestServiceimpl"></bean>
	<bean id="testDAO" class="com.spf.study.TestDAO"></bean>
</beans>

빈을 통한 의존성 주입하는 방법 중 하나는 XML 파일을 통한 방법이다. XML 파일은 root-context.xml 파일이며 내부에 <bean> 태그를 통해 속성으로 id와 class를 추가해서 자바에 대한 객체를 생성해서 스프링 컨테이너에서 관리할 수 있다.

[Spring] 스프링 설정 파일 사용 방법

Untitled_Blue — Mon, 16 Sep 2024 15:53:15 +0900

안녕하세요. 이번 글은 스프링에 대한 설명에서 이어지는 설정 파일 사용하는 방법에 대한 설명입니다.

- 설정 파일 종류

web.xml : 배치 지시자(DD, Deployment Descriptor)로서 웹 애플리케이션의 기본적인 설정 정보를 담고 있는 파일
root-context.xml : Service, DAO, DB 등과 같은 비즈니스 로직을 담당하는 파일이며 여기에 등록된 빈즈는 모든 컨텍스트에 사용가능
servlet-context.xml : 요청과 관련된 객체를 정의하는 파일이며 View와 관련된 Annotation, Controller 등 설정 가능

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

	<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/spring/root-context.xml</param-value>
	</context-param>
	
	<!-- Creates the Spring Container shared by all Servlets and Filters -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- Processes application requests -->
	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
		
	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
    
    <filter>
		<filter-name>encoding</filter-name>
		<servlet-class>org.springframework.web.filter.CharacterEncodingFilter</servlet-class>
		<init-param>
			<param-name>appServlet</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/</url-pattern>
	</filter-mapping>
</web-app>

이 안에 있는 각 태그별 특징과 역할을 분석하고자 한다.

context-param : root-context를 설정해주며 내부에 contextConfigLocation이라는 스프링 동작을 위한 설정파일 위치를 알려주는 파라미터가 적혀있음 (파라미터를 통해 root-context.xml 파일의 위치를 확인할 수 있음.)
listener : ContextLoaderListener 클래스를 통해서 contextConfigLocation에서 확인한 root-context의 파일 위치를 기반으로 스프링 설정파일을 읽고 필요한 객체들을 생성 및 등록하는 역할
servlet : 웹 애플리케이션의 요청을 처리하는 곳이며 DispatcherServlet클래스가 요청과 응답을 모두 담당
servlet-mapping : url-pattern에 설정된 값 요청이 들어오면 servlet-name에 있는 서블릿명을 통해 서블릿 호출
filter : 웹 애플리케이션에서 특정 요청이 있을 때 먼저 실행되는 부분

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
	
	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
	<resources mapping="/resources/**" location="/resources/" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
	<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>
	
	<context:component-scan base-package="com.spring.study" />
</beans:beans>

상단의 XML는 servlet-context.xml이다.

annotation-driven : 스프링에서 어노테이션을 사용하도록 도와주는 역할
resources : 정적인 자원들의 정보를 기술하고 있으며 해당 자원의 위치 정보가 들어가있다.
context:component-scan : package 내 파일에 있는 어노테이션을 읽어들여서 beans로 등록하는 역할
beans:bean : ViewResolver 클래스를 참조해서 property 태그를 통해 파일명 + .jsp를 매칭해주는 역할

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
		
</beans>

상단의 XML는 View를 제외한 나머지 비즈니스 로직을 담당하는 root-context.xml이다. 내부에 DAO, DB를 연결하기 위한 DataSource, TransactionManager등이 추가된다.

[Spring] 스프링 프레임워크에 대한 이해

Untitled_Blue — Sun, 1 Sep 2024 21:43:50 +0900

안녕하세요. 이번 글은 스프링의 첫 글인 스프링 프레임워크에 대한 이해에 대한 글입니다.

- 스프링의 정의 및 구조

웹 애플리케이션 개발을 위한 자바(Java)를 기반으로 제작된 오픈소스 프레임워크
기존 EJB보다 가볍고 배우기 쉽다는 점에서 경량 컨테이너의 기능 수행
제어 역행 (IoC, Inversion of Control)으로 느슨한 결합 제공하며 객체 생명주기의 전반적인 관리 지원 (서블릿 또는 빈 등을 개발자의 코드가 아닌 프레임워크가 직접 수행하는 방식이며 결합도가 느슨할수록 유지보수 및 개발 용이)
의존성 주입 (DI, Dependency Injection)으로 코드의 재사용률을 증가시키며 클래스 객체를 직접 생성이 아닌 프레임워크에서 생성 가능
관점 지향 (AOP, Aspect-Oriented Programming) 지원으로 자원 관리 수행으로 핵심 및 부수 기능 분리 구현으로 모듈성 증가

출처 : https://docs.spring.io/spring-framework/docs/4.0.x/spring-framework-reference/html/overview.html

상단의 그림은 스프링 프레임워크의 주요 기능을 알려주고 있다.

Core Container는 스프링 프레임워크의 기초 모듈이 포함되어 있다.

Core : DI와 IoC를 포함하여 스프링의 기본 부분 제공하는 역할
Beans : 모든 Beans 객체의 전반적인 생명 주기를 관리하며 Beans Factory는 빈즈의 인스턴스를 생성 또는 빈즈의 의존성 문제를 해결하는 역할
Context : 애플리케이션 내 각 기능을 담당한느 Bean에 대한 접근 방법 제공 (Bean 객체들의 의존성 주입 담당)
SpEL : 런타임하는 동안 객체 그래프를 쿼링 및 조작하기 위한 기능 제공하는 역할

Data Access and Integration는 데이터베이스나 메시징 같은 데이터를 통한 상호작용을 지원하는 모듈

JDBC : 쿼리문 형식의 표현을 통한 추상화 형식의 간단한 데이터 표현방법 제공
ORM : Hibernate나 JPA 같은 객체-관계 매핑 프레임워크 통합 기능 제공
OXM : 객체 및 XML 매핑 구현을 지원하는 추상화 계층 지원
JMS : 메세지 생성 및 사용하는 기능 제공
Transactions : 객체의 선언적 트랜잭션 관리 기능 및 일반 프로그래밍 방식 제공

Web은 웹 애플리케이션에 대한 빌드(Bulid)를 지원하는 모듈

Web : 웹 애플리케이션 내 Multipart 파일 업로드 기능 및 IoC 컨테이너 초기화 제공
WebSocket : 클라이언트와 서버 간의 연결통로 제공
Servlet : 스프링 내 MVC (Model-View-Controller) 패턴 제공
Portlet : Web Servlet 모듈의 기능 제공하며 스프링 5 부터는 미지원

AOP 및 Instrumentation는 관점지향 프로그래밍을 지원하면서 성능 모니터링 및 측정 기능을 지원하는 모듈

AOP : 핵심과 부수 로직을 분리하여 부가 기능을 모듈화하여 재사용성 증가
Instrumentation : 오류 확인 및 추적을 위한 성능 모니터링 및 측정 기능 제공

Aspects는 반복적으로 사용되는 로직에 대한 정보를 담아주고 있으며 주로 로직, 보안, 트랜잭션, 인증, 캐싱 등이 있음

- 스프링의 기본 동작 과정

스프링 프레임워크의 실행과정

상단의 이미지는 스프링 프레임워크의 기본 동작을 나타내고 있다. 순서대로 설명하자면 하단과 같다.

클라이언트가 View를 통해 서버에 요청한다.
View를 통해 요청받은 내용을 바탕으로 DispatcherSerlvet는 HandlerMapping을 통해 Controller를 찾아서 반환한다.
찾은 Controller를 기반으로 VO => DAO => DB에 접근하여 데이터 처리 후 나오는 결과를 역순으로 Controller에 반환한다.
다시 DispatcherServlet에 반환받은 데이터를 전송한다.
전송받은 데이터를 ViewResoler를 통해 View를 찾는다.
최종적으로 클라이언트에게 반환받은 데이터를 통한 View를 보여준다.

이때 DispatcherServlet과 ViewResoler는 web.xml 파일에 포함되어있다. 또한 HandlerMapping은 @RequestMapping이라는 어노테이션을 제공하며 이는 Servlet을 설정하는 xml파일에 포함되어있다.

[JSP]JSTL/EL 언어

Untitled_Blue — Fri, 28 Jun 2024 03:00:13 +0900

안녕하세요. 이번 글은 JSTL/EL에 대한 설명입니다.

- JSTL/EL이란?

JSP 페이지 내 자바 코드의 최소화를 위해 만들어진 라이브러리
태그 형식으로 JSP 내 자바 코드를 간결하게 표현가능
JSTL : JSP Standard Tag Library

https://repo1.maven.org/maven2/jstl/jstl/1.2/

Index of /maven2/jstl/jstl/1.2/

repo1.maven.org

JSTL/EL을 사용하기 위해서는 우선 라이브러리를 다운로드 받아야 하며 상단의 링크를 타고 JAR 파일을 다운로드한다.

이후 받은 파일을 프로젝트 내 src > main > webapp > WEB-INF > lib 안에 적용하면 JSTL 라이브러리를 사용할 모든 준비가 완료된다.

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

라이브러리를 사용하기 전 반드시 상단의 태그를 입력해야 한다. 이때 prefix와 uri에 따라 JSTL의 기능이 달라진다.

prefix	url	기능
c	http://java.sun.com/jsp/jstl/core	기본 기능
fmt	http://java.sun.com/jstl/fmt	형식화
sql	http://java.sun.com/jstl/sql	데이터베이스 작업
x	http://java.sun.com/jstl/xml	XML 처리
fn	http://java.sun.com/jsp/jstl/fn	Function (함수) 처리

상단과 같이 총 다섯 가지로 분류되며 그 중에서 먼저 기본 기능을 다뤄보겠다.

- Core 태그

태그명	설명
<c:if>	조건에 따라 처리 로직을 실행하는데 사용
<c:choose>	여러 조건에 따라 처리 로직을 실행하는데 사용
<c:when>	<c:choose>와 같이 사용되며 PL에서 case 처럼 사용
<c:otherwise>	<c:choose>와 같이 사용되며 PL에서 default 처럼 사용
<c:foreach>	일정한 주기에 맞춰 내부 로직을 반복하는데 사용
<c:forToken>	정해진 구분자를 기점으로 각각이 토큰을 처리하는데 사용
<c:set>	변수에 값을 설정하는데 사용
<c:remove>	변수 내 값을 제거하는데 사용
<c:url>	URL에 자동으로 ContextPath를 붙여주는 역할
<c:param>	파라미터를 전달하는데 사용
<c:import>	외부의 자원을 가져와서 활용하는데 사용
<c:redirect>	지정 경로로 이동
<c:catch>	예외처리를 적용하는데 사용
<c:out>	데이터를 출력하는데 사용되며 <%= %>를 대체할 수 있음

JSTL의 종류 중 하나의 Core의 태그는 상단과 같이 있으며 하나씩 실습해보겠다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%
pageContext.setAttribute("msg", "Hello");

%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:if test="${msg == 'Hello'}">
		Hello. today is a JSTL and EL Study day :)
	</c:if>
	<c:if test="${msg != 'Hello'}">
		Nice to meet You :D
	</c:if>
</body>
</html>

상단의 코드는 <c:if test> 태그를 적용한 것이며 msg라는 변수의 값과 조건문 태그에 따라 페이지에 표시되는 문장이 다르다는 점을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%
pageContext.setAttribute("msg", "Hi");

%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:choose>
		<c:when test="${msg == 'Hello'}">
			Hello. today is a JSTL and EL Study day :)
		</c:when>
		
		<c:when test="${msg == 'Hi'}">
			Nice to meet You :D
		</c:when>
		
		<c:otherwise>
			NOPE !
		</c:otherwise>
	</c:choose>
</body>
</html>

상단의 코드는 <c:choose>태그를 사용했으며 이전에 <c:if>와 같은 로직이다. <c:choose>를 사용할 때는 내부에 <c:when>과 <c:otherwise>를 사용해서 조건문에 대한 로직을 생성할 수 있음을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:forEach var="i" begin="1" end="10" step="1">
		${i}번째 반복 <br>
	</c:forEach>
</body>
</html>

상단의 코드는 <c:forEach var="i" begin="[시작값]" end="[종료값]" step="[주기]"> 태그를 사용하여 반복문을 구현하였다. 내부에 ${[var]}를 적용하여 반복하고 있는 숫자를 화면에 보여줄 수도 있다는 점을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:forTokens var="PL" items="C/Java/Python/C++/C#/Kotiln" delims="/">
		<c:out value="${PL}"/> <br>
	</c:forTokens>
</body>
</html>

다음은 <c:forToken var="[변수명]" items="[데이터]" delims="[구분자]">태그를 사용해서 배열처럼 되어있는 문자열에서 구분자를 활용해서 값을 나누는 것을 구현한 코드이다. 그리고 이를 표현하기 위해 <c:out value="${[변수명]}"/>을 활용했다는 점을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:url var="Paging" value="/JSTL_Practice002.jsp">
		<c:param name="name" value="홍길동"/>
	</c:url>
	
	<a href="${Paging}">페이지 이동</a>
</body>
</html>

상단 코드는 <c:url var="[변수명]" value="[경로]">과 <c:param name="[변수명]" value="[값]">을 활용해서 데이터와 함께 세션을 유지하는 방향으로 사이트를 이동하는 기능을 구현하고 있다.

다음과 같이 실행하면 param 값과 세션아이디가 동시에 다른 사이트로 넘어가면서 정보와 세션값을 그대로 유지 가능한 점을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<c:redirect url="/JDBC_Select.jsp" context="/2023_JSP_Study">
		<c:param name="user" value="홍길동"/>
	</c:redirect>
</html>

상단 코드는 <c:redirect> 태그를 사용하여 특정 사이트 또는 위치로 리다이렉트 시켜주는 기능을 담당하고 있다.

해당 코드를 실행하면 지정해둔 위치로 자동으로 이동되는 점을 확인할 수 있다.

- XML 태그

태그명	설명
<x:parse>	XML 문서를 읽어서 파싱
<x:out>	XML 내용 출력
<x:if>	조건에 따라 내부 로직 실행
<x:forEach>	일정 주기 및 데이터 길이에 맞춰 내부 로직 반복하는 데 사용
<x:choose>	여러 조건에 따라 로직 처리하는 데 사용
<x:when>	<x:choose>와 함께 사용되며 조건 설정 및 내부 로직 구성에 사용
<x:otherwise>	<x:choose>와 함께 사용되며 어느 조건에도 부합하지 않을 때 실행되는데 사용

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
	<body>
		<c:set var="Sample">
		  <info>
		    <artist>
		        <name>IVE</name>
		        <debut>2021</debut>
		        <agency>STARSHIP Ent.</agency>
		    </artist>
		        
		    <artist>
		        <name>asepa</name>
		        <debut>2020</debut>
		        <agency>SM Ent.</agency>
		    </artist>
		  </info>
		</c:set>
	
		<!-- out -->
		<x:parse xml="${Sample}" var="output"/>
		<b>아티스트 1</b> : <x:out select="$output/info/artist[1]/name" />
		
		<br>
		
		<b><x:out select="$output/info/artist[2]/name" />의 소속사</b> : <x:out select="$output/info/artist[2]/agency" />
		
		<br> <br>
		
		<!-- forEach -->
		<x:forEach select="$output/info/artist/name" var="item">
		    <b>아티스트 명 : <x:out select="$item" /></b> <br>
		</x:forEach>
		
		<br>
		
		<!-- if -->
		<x:if select = "$output//artist">
		   해당 XML 문서에는 최소 한 명 이상의 아티스트의 정보가 담겨있습니다.
		</x:if>
		
		<br> <br> 
		
		<!-- choose -->
		<x:choose>
		  <x:when select="$output//artist/debut='2021'">
		    <x:out select="$output//artist/name"/>은(는) <x:out select="$output//artist/debut"/>년에 데뷔했습니다.
		  </x:when>
		  
		  <x:when select="$output//artist/debut='2020'">
		    <x:out select="$output//artist/name"/>은(는) <x:out select="$output//artist/debut"/>년에 데뷔했습니다.
		  </x:when>
		  
		  <x:otherwise>
		    NO DATA.
		  </x:otherwise>
		</x:choose>
	</body>
</html>

상단의 코드는 XML JSTL 태그를 활용한 코드이며 이때 경로를 설정할 때는 '/'는 절대경로이며 '//'는 모든경로를 의미한다.

- Format 태그

태그명	설명
formatNumber	숫자를 양식에 맞춰 출력
formatDate	날짜 정보를 포맷팅하여 출력
parseDate	문자열 -> 날짜로 변환
parseNumber	문자열 -> 숫자로 변환
setTimeZone	시간대별로 시간을 처리할 수 있는 기능 제공
timeZone	시간대별로 시간을 처리할 수 있는 기능 제공
setLocale	로케일 지정
requestEncoding	요청 파라미터의 인코딩 형식 지정
bundle	태그 몸체에서 사용할 리소스 번들 제공
message(param)	메시지 출력
setBundle	리소스 번들 사용가능하도록 설정

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
	<body>
		groupingUsed = true : <fmt:formatNumber value="1000000"/> <br>
		groupingUsed = false : <fmt:formatNumber value="1000000" groupingUsed="false"/> <br>
		
		<br>
		
		currency Dollar : <fmt:formatNumber value="10000" type="currency"/> <br>
		currency KRW : <fmt:formatNumber value="10000" type="currency" currencySymbol="KRW"/> <br>
		
		<br>
		
		Percent : <fmt:formatNumber value="0.3" type="percent"/> <br>
	</body>
</html>

속성	설명
var	출력 결과에 데한 데이터를 대입하는 역할
scope	변수에 대한 효력을 지정하는 역할
value	형식화 대상 데이터
type	number, percent, currency 중 하나이며 출력할 포맷 타입 지정
groupingUsed	콤마(,) 지정
pattern	사용자 지정 패턴
currencySymbol	통화 기호 설정

속성은 다음과 같으며 상단의 코드를 실행하면 이미지와 같은 결과가 출력되는 점을 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
	<body>
		<c:set var="now" value="<%=new java.util.Date()%>"/>
		
		Original : ${now} <br>
		FormatDate : <fmt:formatDate value="${now}" type="date"/>, <fmt:formatDate value="${now}" type="time"/>, <fmt:formatDate value="${now}" type="both"/> <br>
		
		dateStyle : <fmt:formatDate value="${now}" dateStyle="short"/>, <fmt:formatDate value="${now}" dateStyle="medium"/>, <fmt:formatDate value="${now}" dateStyle="long"/>, <fmt:formatDate value="${now}" dateStyle="full"/>, <fmt:formatDate value="${now}" dateStyle="default"/>
		<br>
		timeStyle : <fmt:formatDate value="${now}" timeStyle="short"/>
		<br>
		pattern : <fmt:formatDate value="${now}" pattern="yyyy년 MM월 dd일 hh : mm : ss"/>
		<br>
		<fmt:timeZone value="GMT">
		timeZone : <fmt:formatDate value="${now}" />
		</fmt:timeZone>
	</body>
</html>

속성	설명
var	출력 결과에 데한 데이터를 대입하는 역할
scope	변수에 대한 효력을 지정하는 역할
value	형식화 대상 데이터
type	형식화할 데이터 종류이며 time, date, both 중 하나 사용 가
dateStyle	지정된 날짜 형식이며 default, short, mediun, long 중 하나 사용 가능
timeStyle	지정된 시간 형식이며 default, short, mediun, long 중 하나 사용 가능
pattern	사용자 지정 형식 스타일
timeZone	타임존 설정

속성은 다음과 같이 구성되어 있으며 상단의 소스코드를 출력하면 상단의 이미지와 같은 결과를 확인할 수 있다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
	<body>
		<c:set var="now" value="<%=new java.util.Date()%>"/>
		
		<fmt:setLocale value="ko_kr"></fmt:setLocale>
			<fmt:formatDate value="${now}" type="both"/>
			<fmt:formatNumber type="currency" value="100000"/>
		
		<br> <br>
		
		<fmt:setLocale value="ja_JP"></fmt:setLocale>
			<fmt:formatDate value="${now}" type="both"/>
			<fmt:formatNumber type="currency" value="100000"/>
			
		<br> <br>
		
		<fmt:setLocale value="en_US"></fmt:setLocale>
			<fmt:formatDate value="${now}" type="both"/>
			<fmt:formatNumber type="currency" value="100000"/>
	</body>
</html>

다음과 같이 formatDate, formatNumber를 사용하기 전에 <fmt:setLoacle value="[국가]"></fmt:setLocale>를 선언해주면 해당 국가에 맞는 통화기호와 시차에 의거한 날짜 및 시간 및 표기법까지 출력되는 점을 확인할 수 있다.

- SQL

<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<sql:setDataSource driver="[com.oracle.jdbc.Driver]" url="[URL]" user="[USER]", password="[PSWD]" var="[VALUE]", scope="[page | request | session | application]"/>

상단의 코드는 웹과 데이터베이스와 연결을 위한 필수적인 요소이다.

<sql:query var="val01" dataSource="${dataSource}">
	SELECT * FROM TAB;
</sql:query>

해당 sql:query 태그는 SELECT 쿼리문을 실행하는데 사용된다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
	<body>
		<sql:setDataSource driver="oracle.jdbc.driver.OracleDriver" url="jdbc:oracle:thin:@localhost:1521:orcl" user="scott" password="1234" var="dataSource" scope="page"/>
		<sql:query var="resultSet" dataSource="${dataSource }">
			SELECT * FROM DEPT
		</sql:query>
		
		<table border="1">
			<tr>
				<c:forEach items="${resultSet.columnNames}" var="col_print">
					<th>${col_print}</th>
				</c:forEach>
				<c:forEach items="${resultSet.rowsByIndex}" var="row_print">
				<tr> 
					<c:forEach items="${row_print}" var="row_print_row">
						<td>${row_print_row}</td>
					</c:forEach>
			</tr>
			</c:forEach>
		</table>
	</body>
</html>

다음과 같이 <sql:query> 태그를 사용 후 그에 대한 데이터가 출력되며 이를 토대로 <c:forEach>와 변수명.columsNames와 변수명.rowsByIndex를 사용하여 데이터를 웹 화면에 출력할 수 있는 점을 확인할 수 있다.

<sql:update dataSource="${dataSource}">
	INSERT INTO DEPT VALUES(?,?,?)
		
	<sql:param value="50"/>
	<sql:param value="=IT Dept."/>
	<sql:param value="Korea"/>
</sql:update>

다음과 같이 <sql:update> 태그를 사용하여 데이터와 대한 입력, 수정, 삭제 작업이 가능한 점을 확인할 수 있으며 <sql:param> 태그를 사용하여 사용할 값을 지정할 수 있다.

- Fn 태그

태그	설명
fn.toLowerCase(String)	String 문자열의 알파벳을 소문자로 변환
fn.toUpperCase(String)	String 문자열의 알파벳을 대문자로 변환
fn.substring(String, begin, end)	String 문자열에서 begin에서부터 end까지의 문자열 반환
fn.substringBefore(String, substr)	String 문자열에서 substr 이전의 문자 반환
fn.subStringAfter(String, substr)	String 문자열에서 substr 이후의 문자 반환
fn.trim(String)	String 문자열의 앞뒤 공백 모두 제거
fn.length(String)	String 문자열의 글자의 갯수 반환
fn.replace(String, before, after)	String 문자열에서 이전 문자를 새로운 문자로 대
fn.join(array[], separator)	배열을 특정 문자를 기점으로 각각의 문자열로 분리

- EL 표현언어

객체	설명
param	파라미터의 값 담고 있는 객체
paramValues	동일 명의 파라미터 값들을 배열 형태로 담고 있는 객

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
	<body>
		<form action="Result.jsp" method="GET">
			ID : <input type="text" name="id" id="id"/> <br>
			PW : <input type="password" name="pwd" id="pwd"/> <br>
			
			<br>
			
			<input type="checkbox" name="dept" value="인문사회"> 인문사회
			<input type="checkbox" name="dept" value="자연계열"> 자연계열
			<input type="checkbox" name="dept" value="공학"> 공학
			<input type="checkbox" name="dept" value="예체능"> 예체능
			
			<br><br>
			
			<input type="submit"/>
		</form>
	</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	Result : ${param.id}, ${param.pwd} <br>
	Dept : 
	
	<c:forEach items="${paramValues.dept}" var="dept">
	 	${dept} 
	</c:forEach>
</body>
</html>

다음 코드는 EL 표현 언어를 사용하여 form 태그에서 입력했던 데이터를 전송했을 때 기존에는 request.getParameter("[name]")을 사용했던 것을 간결하게 표현해서 전송한 데이터를 보여주는 것을 확인할 수 있다.

[JSP] cos.jar를 활용한 파일 업로드

Untitled_Blue — Wed, 12 Jun 2024 13:06:05 +0900

안녕하세요. 이번 글은 파일 업로드에 대한 설명입니다.

- cos.jar

JSP&Servlet에서 파일 업로드 기능을 구현하기 위한 라이브러리
http://www.servlets.com/

Servlets.com

Home What's New? COS File Upload Library Servlet Polls Mailing Lists Servlet Engines Servlet ISPs Servlet Tools Documentation Online Articles The Soapbox "Java Servlet Programming, Second Edition" "Java Enterprise Best Practices" Speaking & Slides About Ja

www.servlets.com

상단의 사이트로 접속하면 좌측에 com.oreilly.servlet이 있는데 클릭 후 최하단으로 스크롤을 내리면 이미지처럼 다운로드 링크가 있을 것이다. 이를 통해 라이브러리를 다운로드해주면 된다.

이후 이클립스(또는 인텔리제이)를 실행하여 적용하고자 하는 프로젝트 안에 있는 src > main > webapp > WEB-INF > lib 폴더 안에 파일을 넣어서 적용해주면 cos.jar 라이브러리를 사용하기 위한 모든 준비가 완료된다.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>FileUploadForm1</title>
</head>
<body>
	<h2>FileUpload</h2>
	
	<form action="<%=request.getContextPath() %>/File.do" name="FileUpload" method="post" enctype="multipart/form-data">
		<input type="file" name="FileInfo">
		<input type="submit" name="업로드">
	</form>
</body>
</html>

상단의 JSP 소스코드는 파일을 업로드하기 위한 폼 양식을 구현하고 있다. 이때 필수적으로 사용하는 태그는 form과 input가 있는데 form 안에 속성은 enctype="multipart/form-data" 및 method="post"를 사용해야 한다. 또한 내부에 input type은 file과 submit이 있어야만 업로드할 파일을 선택하고 제출해서 서버에 업로드할 수 있다. 이제 백엔드 코드를 살펴보자.

package Testing;

import java.io.File;
import java.io.IOException;
import java.util.Enumeration;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;

@WebServlet("/File.do")
public class FileController extends HttpServlet {
    public FileController() {
        super();
    }

	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		response.getWriter().append("Served at: ").append(request.getContextPath());
		
		String fileSavePath = "C:/Users/users/Documents/eclipse-jee-2023-03-R-win32-x86_64/eclipse/WorkSpace/2023_JSP_Study/src/main/webapp/FileDict";
		String encType = "EUC-KR";
		int maxSize = 100*1024*1024; // 100MB
		
		try {
			MultipartRequest multi = null;
			multi = new MultipartRequest(request, fileSavePath, maxSize, encType, new DefaultFileRenamePolicy());
			Enumeration params = multi.getParameterNames();
			
			while (params.hasMoreElements()) {
				String name = (String)params.nextElement();
				String value = multi.getParameter(name);
				System.out.println("name : " + name + ", value : " + value);
			}
			
			Enumeration files = multi.getFileNames();
			
			while(files.hasMoreElements()) {
				String name = (String) files.nextElement();
				
				String fileName = multi.getFilesystemName(name);
				String original = multi.getOriginalFileName(name);
				String type = multi.getContentType(name);
				
				File f = multi.getFile(name);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		RequestDispatcher rd = request.getRequestDispatcher("/FileUploadTest.jsp");
		
		rd.forward(request, response);
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

상단의 코드는 cos.jar 라이브러리를 적용해서 파일 업로드를 구현해주는 소스코드이다. 먼저 MultipartRequest 클래스를 이해해야 한다.

MultipartRequest multi = new MultipartRequest(HttpServletRequest request, String saveDirectory, int maxSize, String encoding, FileRenamePolicy policy)

MultipartRequest 클래스를 사용하기 위해서는 먼저 상단의 생성자를 통한 객체를 생성해줘야 한다. 매개변수는 크게 5개를 사용하는데 saveDirectory는 파일을 저장할 경로를 뜻하며 maxSize는 업로드 최대 허용 용량크기, encoding은 인코딩 타입을 의미한다. 나머지 두 개 중 마지막에 있는 FileRenamePolicy policy은 보통 new Default FileRenamePolicy()를 사용하는데 이는 기존에 업로드한 파일명과 업로드될 파일명이 같을 경우 덮어쓰기를 방지하기 위해 사용되고 있다.

메서드	리턴 타입	의미
.getContentType(String name)	String	업로드된 파일의 형식을 반환
.getFile(String name)	File	업로드된 파일의 객체를 반환
.getFileNames()	Enumeration	프론트 내 input type="file"으로 된 파라미터의 이름 반환
.getFilesystemName(String name)	String	실제로 업로드된 파일명을 문자열로 반환
.getOriginalFileName(String name)	String	업로드된 파일명을 반환하나 중복 가능성 고려하여 변경 전 이름 반환
.getParameter(String name)	String	객체에 있는 파라미터를 문자열로 반환
.getParameterNames()	Enumeration	모든 파라미터의 이름 반환
.getParameterValues(String name)	String[]	폼으로부터 전송된 파라미터를 배열로 반환

상단의 메서드 8개는 파일 업로드 기능을 구현하기 위해 자주 사용되는 메서드다.

[SQL] 트리거 (Trigger)

Untitled_Blue — Thu, 6 Jun 2024 20:54:05 +0900

안녕하세요. 이번 글은 트리거에 대한 설명입니다.

- 트리거(Trigger)란?

데이터베이스 내 특정 이벤트(상황, 동작)이 발생할 때 자동으로 실행되는 기능을 정의하는 PL/SQL 서브 프로그램
특정 데이터 또는 작업과 연관된 여러 작업을 통합하여 한 번에 수행가능
복잡한 데이터 규칙을 정의하여 데이터 처리 가능
데이터 변경 관련 일련의 정보 기록 가능함으로써 데이터 보안성, 안정성 보장가능하며 문제 시 대처 능력 기대 가능

CREATE OR REPLACE [트리거명]

BEFORE [|| AFTER]
	INSERT || UPDATE || DELETE ON [테이블명]

REFERENCING OLD AS old || NEW AS new

FOR EACH ROW WHEN [조건식]

FOLLOWS [트리거명]

ENABLE || DISABLE

DECLARE
	[선언부]
    
BEGIN
	[실행 로직]
 
EXCEPTION
	[예외 처리부]

END;
/

BEFORE, AFTER : 트리거가 작동할 타이밍 지정하는 역할 담당 (명령어 실행 전과 후로 분류)
INSERT, UPDATE, DELETE ON [테이블명] : 트리거가 작동할 DML 명령어 지정하며 여러 개일 경우 || (OR) 사용
REFERENCING OLD AS OLD, NEW AS NEW : 생략 가능하며 DML로 인해 변경되는 행의 변경 전과 후를 참조하는데 사용
FOR EACH ROW WHEN [조건식] : 생략 가능하며 DML 명령어에 영향받는 행별로 실행할 지 한 번만 실행할 지를 결정하는 역할 담당
FOLLOWS [트리거명] : 생략 가능하며 여러 관련된 트리거 실행 순서 지정하는 역할 담당
ENABLE, DISABLE : 생략 가능하며 트리거의 활성화 여부 체크하는 역할 담당

CREATE OR REPLACE TRIGGER TEST_TRIG_001

BEFORE
    INSERT OR UPDATE ON STUDENT_INFO

    FOR EACH ROW

BEGIN
       IF INSERTING THEN
           INSERT INTO STUDENT_INFO_LOG (STU_NAME, STU_NUM, STU_GRADE, STU_COLLAGE, STU_DEPT, STU_ACA, STU_GENDER, ADD_DATE, CUD_TYPE)
           VALUES (:NEW.STU_NAME, :NEW.STU_NUM, :NEW.STU_GRADE, :NEW.STU_COLLAGE, :NEW.STU_DEPT, :NEW.STU_ACA, :NEW.STU_GENDER, SYSDATE, 'C');
       ELSIF UPDATING THEN
           INSERT INTO STUDENT_INFO_LOG (STU_NAME, STU_NUM, STU_GRADE, STU_COLLAGE, STU_DEPT, STU_ACA, STU_GENDER, ADD_DATE, CUD_TYPE)
           VALUES (:NEW.STU_NAME, :NEW.STU_NUM, :NEW.STU_GRADE, :NEW.STU_COLLAGE, :NEW.STU_DEPT, :NEW.STU_ACA, :NEW.STU_GENDER, SYSDATE, 'U');
       ELSE
           RAISE_APPLICATION_ERROR(-20003, 'ETC ERROR');
       END IF;
END;
/

상단 쿼리문은 학생정보 테이블에 대한 CRUD 작업 시 학번에 대한 정보를 처리했던 이력을 관리하기 위한 트리거이다. 이때 작동할 타이밍은 BEFORE로 설정하였으며 명령어 실행 전 해당 트리거가 작동되며 작동 후 DML 명령어에 대한 실행 결과가 발생하는 점을 확인할 수 있다.

SELECT * FROM USER_TRIGGERS;

상단 USER_TRIGGERS 데이터 사전을 사용하면 본인이 만들었던 트리거를 확인할 수 있다.

INSERT INTO STUDENT_INFO 
VALUES ('김땡땡', '20226459', '3', '간호대학', '간호학과', '재학', '남자');

UPDATE STUDENT_INFO
   SET STU_ACA = '휴학'
 WHERE STU_NUM = '20226459';

상단처럼 INSERT와 UPDATE문을 실행하면 트리거가 작동할 것이다.

실행 후 트리거에서 INSERT 대상이었던 STUDENT_INFO_LOG 테이블을 조회하면 다음과 같이 이력이 저장되어있는 점을 확인할 수 있다.

CREATE OR REPLACE TRIGGER TEST_TRIG_002

AFTER
    DELETE ON STUDENT_INFO

    FOR EACH ROW

BEGIN
       IF DELETING THEN
           INSERT INTO STUDENT_INFO_LOG (STU_NAME, STU_NUM, STU_GRADE, STU_COLLAGE, STU_DEPT, STU_ACA, STU_GENDER, ADD_DATE, CUD_TYPE)
           VALUES (:OLD.STU_NAME, :OLD.STU_NUM, :OLD.STU_GRADE, :OLD.STU_COLLAGE, :OLD.STU_DEPT, :OLD.STU_ACA, :OLD.STU_GENDER, SYSDATE, 'D');
       ELSE
           RAISE_APPLICATION_ERROR(-20003, 'ETC ERROR');
       END IF;
END;
/

다음은 삭제할 때 작동하는 트리거를 실행할 것인데, 이때 이전과는 다르게 AFTER와 OLD 키워드를 사용하였다. 이를 통해 상단의 트리거가 DML문이 실행된 후에 트리거가 작동하는 것과 동시에 OLD 키워드를 통해 갱신 또는 삭제 이전의 데이터를 의미한다는 점을 알 수 있다.

DELETE FROM STUDENT_INFO WHERE STU_NUM = '20226459';

다음과 같이 상단의 쿼리문을 실행하면 이미지처럼 트리거가 실행되면서 삭제한 이력이 테이블에 저장된 점을 확인할 수 있으며 효율적인 이력관리 및 손쉬운 복구가 가능한 점을 알 수 있다.

[SQL] 함수 (Function)

Untitled_Blue — Sat, 18 May 2024 21:24:26 +0900

안녕하세요. 이번 글은 함수에 대한 설명입니다.

- 함수란?

SQL문과 프로시저, 트리거에서 다양하게 사용가능하며 함수 안에 로직을 생성하여 사용하는 키워드
프로그래밍 언어에 비유하면 메서드 (Method)와 유사한 개념
프로시저와 다르게 IN 파라미터만 사용가능
반드시 최소 하나의 값은 반환해야 하며 RETURN 키워드를 사용

CREATE [OR REPLACE] FUNCTION [함수명] (
	[변수명] IN [자료형],
    ...
    [변수명] IN [자료형]
)

RETURN [자료형]

IS
	[변수명] [자료형] := [값 또는 식];
BEGIN
	[내부 로직];
	RETURN [값 또는 식];
END;
/

함수를 구성하는 내부 로직은 상단과 같다. 첫 번째 라인에 있는 CREATE OR REPLACE [함수명]은 프로시저처럼 함수를 생성하면서 동일한 이름의 함수가 있으면 덮어쓰기처럼 대체하겠다는 키워드로 시작한다. 이후 파라미터를 지정하고 RETURN [자료형]을 통해 함수 실행 후 반환받을 값에 대한 자료형을 지정하며 BEGIN문 내부에 RETURN 옆에 반환 값 또는 식을 지정함으로써 반환 값을 설정하는 것을 끝으로 함수를 끝마치는 구조인 점을 확인할 수 있다. 삭제할 때는 DROP FUNCTION [함수명];을 사용하면 된다.

CREATE OR REPLACE FUNCTION TEST_FUNC_001 (
    BRITH IN NUMBER
)

RETURN NUMBER

IS
    TODAY DATE := SYSDATE;

BEGIN
    RETURN ROUND(TO_NUMBER(TODAY - TO_DATE(BRITH)) / 365, 1);
END;
/

상단의 PL/SQL문은 생년월일을 입력하면 작성자의 만 나이를 계산해주는 함수이다.

DECLARE
    BIRTH NUMBER;
    RESULT VARCHAR2(100);
BEGIN
   BIRTH := 19960518;
   RESULT := TEST_FUNC_001(BIRTH);

   DBMS_OUTPUT.PUT_LINE('RESULT : ' || RESULT);
END;

함수를 실행해보면 다음과 같이 내부 로직에 의거하여 결과를 출력할 수 있는 점을 확인할 수 있다.

SELECT TEST_FUNC_001(19960518) FROM DUAL;

하지만 DECLARE, BEGIN, END문을 사용해서 일일이 함수를 실행하기에는 상대적으로 번거롭다. 그래서 FROM DUAL을 통해 상단 쿼리문처럼 SQL문에서 함수를 선언해서 직접적으로 실행시킬 수도 있다. 차이점이 있다고 하면 PL/SQL문으로 실행하는 함수는 콘솔창에 결과가 출력되고 쿼리문에서 실행하는 함수는 테이블 형식으로 결과가 나오며 데이터 조회 및 처리할 때 상대적으로 다양하고 유연하게 적용시킬 수 있다는 점이 존재한다.

[SQL] 프로시저 (Procedure)

Untitled_Blue — Wed, 15 May 2024 17:14:31 +0900

안녕하세요. 이번 글은 프로시저에 대한 설명입니다.

- 프로시저란?

특정 처리 작업을 수행하기 위해 사용하는 저장 서브프로그램
일정한 논리와 로직에 의거하여 데이터 처리 작업을 수행하는 역할 담당

CREATE [OR REPLACE] PROCEDURE [프로시저명]

IS [AS]
	[변수명] [자료형] := [값 또는 식];
BEGIN
	[내부 로직];
EXCEPTION
	[예외 시 실행 로직];
END;
/

프로시저의 구조는 다음과 같이 진행되며 각 구문에 대한 설명은 하단과 같다.

CREATE PROCEDURE : 프로시저를 생성하기 위한 구문이며 CREATE 뒤에 OR REPLACE를 추가하면 현재 작성한 내용으로 새로 대체되며 나중에 프로시저를 수정하는 작업할 때 주로 활용되고 있음
IS, AS, BEGIN : 선언부를 의미하며 선언부 내 변수를 지정하지 않아도 반드시 선언해야 함
EXCEPTION : 예외부를 의미하며 실행 중 예외 상황에 대처하기 위한 구간 (선택)
END : 프로시저의 끝을 의미

CREATE OR REPLACE PROCEDURE TEST_PROC
IS
    V_NAME VARCHAR2(100) := '김땡땡';
    V_DEPT VARCHAR2(150) := '컴퓨터공학과';
    V_AGE NUMBER(10) := 26;
BEGIN
    DBMS_OUTPUT.PUT_LINE('V_NAME : ' || V_NAME);
    DBMS_OUTPUT.PUT_LINE('V_DEPT : ' || V_DEPT);
    DBMS_OUTPUT.PUT_LINE('V_AGE : ' || V_AGE);
END;
/

상단의 쿼리문은 프로시저를 생성하는 역할을 담당하고 있다. 해당 쿼리문을 실행해보면 Console창에 completed in 218 ms 같이 생성 및 대체가 완료되었다는 알림과 함께 목록에서 프로시저가 정상적으로 반영된 점을 확인할 수 있다.

SET SERVEROUTPUT ON;
EXECUTE TEST_PROC;

오라클 SQL*PLUS 기준으로 상단처럼 실행하면 된다.

BEGIN
    SCOTT.TEST_PROC;
END;

PL/SQL 블록이나 별도의 DB툴에서는 상단과 같이 입력해서 실행하면 정상적으로 출력되는 점을 확인할 수 있다.

(필자는 Oracle 19.3 + DataGrip 2023.03 툴을 사용하고 있다.)

SELECT * FROM USER_SOURCE;

프로시저에 대한 전반적인 내용을 확인하기 위해서는 USER_SOURCE라는 데이터 사전을 확인하면 된다.

DROP PROCEDURE TEST_PROC;

프로시저를 삭제할 때는 DROP PROCEDURE [프로시저명]을 사용하면 된다.

CREATE OR REPLACE PROCEDURE [프로시저명] (
    [파라미터명] [IN | OUT | IN OUT] [자료형] [:= || DEFAULT 기본값],
    [파라미터명] [IN | OUT | IN OUT] [자료형] [:= || DEFAULT 기본값],
    ...
)

IS [또는 AS]
    [선언부]
BEGIN
    [수행 로직]
EXCEPTION
    [예외처리 로직]
END;
/

상단 쿼리문 구조는 파라미터(Parameter)를 사용하는 프로시저의 구조를 보여주고 있다. 이전 프로시저 구조와 다른 점이 있다면 프로시저를 실행하기 위한 값을 입력받는 구간인 파라미터의 존재 여부에서 차이점이 존재한다. 여러 개의 파라미터를 설정할 때는 세미콜론이 아닌 쉼표(,)로 구분하며 값을 입력받는 파라미터의 구조는 [파라미터명] [파라미터 모드] [자료형] [:= 또는 DEFAULT 기본값]이며 파라미터명과 자료형을 제외한 나머지 두 개는 선택사항이다.

파라미터 모드	설명
IN	값을 지정하지 않으면 기본값으로 입력받음 (생략 가능)
OUT	호출 시 값 반환
IN OUT	호출 시 값을 입력받고 실행 결과에서 값 출력

상단의 표는 파라미터 모드에 대한 설명을 담고 있다.

create OR REPLACE PROCEDURE TEST_PROC_PARAM (
    V_NAME IN VARCHAR2,
    V_GRADE IN NUMBER DEFAULT 2,
    V_AGE IN OUT NUMBER,

    V_RESULT OUT VARCHAR
)

AS
    V_CHECK NUMBER(10) := 0;

BEGIN
    SELECT COUNT(*) INTO V_CHECK
      FROM STUDENT_INFO
     WHERE STU_NAME = V_NAME
       AND STU_GRADE = V_GRADE;

    IF V_CHECK > 0 THEN
        DBMS_OUTPUT.PUT_LINE('해당 학생은 존재합니다.');
    ELSE
        DBMS_OUTPUT.PUT_LINE('해당 학생은 없습니다.');
    END IF;

    V_RESULT := '결과 출력을 마칩니다.';

   DBMS_OUTPUT.PUT_LINE(V_RESULT || V_AGE);
END;
/

상단의 쿼리문은 프로시저에서 DECALRE 선언부에 IN, OUT, IN OUT 파라미터를 사용한 PL/SQL문이다. IN을 통해 실행에 필요한 값을 입력받도록 구현하였으며 OUT을 통해 실행 후 내부 로직을 거쳐서 출력되는 값을 확인할 수 있다. 그리고 IN OUT을 통해 입력과 출력에 대한 기능을 동시에 사용가능한 점을 확인할 수 있다.

DECLARE
    TEST_OUT VARCHAR2(100);
    AGE_IO NUMBER;
BEGIN
    AGE_IO := 20;
    SCOTT.TEST_PROC_PARAM('홍길동', 2, AGE_IO, TEST_OUT);

    DBMS_OUTPUT.PUT_LINE(TEST_OUT || ' ' || AGE_IO);
END;

상단의 쿼리문은 이전에 확인했던 TEST_PROC_PARAM 프로시저를 실행하기 위한 것이며 프로시저명([파라미터값1], [파라미터값2] ..)을 통해서 작동해야 되며 괄호 안에 선언해둔 파라미터 갯수대로 반드시 맞춰야 한다. 하지만 IN과 다르게 OUT과 IN OUT은 선언부에 [변수명] [자료형]; 방식으로 선언한 뒤 BEGIN에다 괄호 안에 입력해야 한다. 그 중에서 IN OUT은 IN의 기능도 가지고 있기 때문에 BEGIN 문에다 값을 대입해야 한다. 또한 OUT과 IN OUT에 대한 결과를 출력받기 위해서는 프로시저문에다가도 설정할 수 있으나 실행문에서도 DBMS_OUTPUT.PUT_LINE()을 통해서 출력할 수 있다.

[SQL] PL/SQL

Untitled_Blue — Sun, 12 May 2024 16:00:25 +0900

안녕하세요. 이번 글은 PL/SQL에 대한 설명입니다.

- PL/SQL이란?

DB와 관련된 작업을 수행하는 명령어와 실행 필수 요소를 정의하는 명령어의 집합

키워드	필수 유무	설명
DECLARE	선택	선언부이며 실행에 필요한 변수, 상수, 커서 등 선언하는 공간
BEGIN	필수	실행부이며 조건문, 반복문, 함수, SELECT, DML 등을 정의하는 공간
EXCEPTION	선택	실행 중 발생하는 예외 및 오류를 다루는 공간

상단의 표는 PL/SQL를 다루기 위해서 필요하는 기본적인 블록에 대한 설명을 담고 있다. 선언부와 예외는 선택적으로 다룰 수도 있지만 BEGIN은 필수이다.

DECLARE
    BEGIN

	-- 한 줄 주석
    /*
    여러 문 주석
    입니다.
    */
    DBMS_OUTPUT.PUT_LINE('This is PL/SQL Printing');
    DBMS_OUTPUT.PUT_LINE(SYSDATE);

    END;
/

다음과 같이 DBMS_OUTPUT.PUT_LINE()을 통해 프로그래밍 언어에서 실습했던 출력문처럼 Console문을 출력할 수 있는 점을 확인할 수 있다. 또한 주석도 작성할 수 있는데 -- 을 통해 한 줄 주석을 작성할 수 있으며 /**/을 통해 여러 줄로 주석 작성할 수도 있다. PL/SQL을 작성할 때는 세미콜론(;)은 출력문과 END문에만 사용해야 한다. PL/SQL문의 작성을 마칠 때는 실행을 위해 반드시 슬래시(/)을 붙여야 한다.

DECLARE
    V_AGE NUMBER(10) := 26;
    V_NAME VARCHAR2(50) := '홍길동';
    V_COMMENT VARCHAR2(100);

BEGIN
    V_COMMENT := 'HELLO. HAVE A GOOD DAY :)';
    DBMS_OUTPUT.PUT_LINE(V_NAME || '님 (' || V_AGE || ')의 멘트 : ' || V_COMMENT);
    DBMS_OUTPUT.PUT_LINE(SYSDATE);

END;
/

상단의 쿼리문은 DECLARE 선언부를 활용한 PL/SQL문이다. 해당 쿼리문을 실행해보면 선언부에 설정해둔 변수를 기반으로 작성한 출력문이 콘솔창에 출력되는 것을 확인할 수 있다. 이처럼 변수 선언할 때는 [변수명] [자료형] := [값 또는 식]을 통해 선언 및 활용할 수 있다. 또한 프로그래밍 언어처럼 선언부에 선언만 한 채로 BEGIN문에다 변수에 값 또는 식을 대입시킬 수도 있다. 자료형은 NUMBER(), VARCHAR(), VARCHAR2(), DATE, BOOLEAN 총 다섯 가지로 구성되어있다.

DECLARE
    VC_NUMBER CONSTANT NUMBER(10) := 10;

BEGIN
    DBMS_OUTPUT.PUT_LINE('VC_NUMBER : ' || VC_NUMBER);

    VC_NUMBER := 20;
    DBMS_OUTPUT.PUT_LINE('VC_NUMBER : ' || VC_NUMBER);

END;
/

상단의 쿼리문은 CONSTANT라는 키워드를 사용해서 상수를 선언하고 값을 할당한 쿼리문이다. 해당 쿼리문을 실행하면

ORA-06550: 줄 7, 열5:PLS-00363: 'VC_NUMBER' 식은 피할당자로 사용될 수 없습니다, 줄 7, 열5 :PL/SQL: Statement ignored 라는 오류에 대한 알림이 발생하는 점을 확인할 수 있다. 이와 같은 오류가 발생하는 이유는 상수라는 키워드 특성상 한 번 값을 할당하면 더 이상의 재할당이 안되기 때문이다. 프로그래밍 언어처럼 상수는 변수와 달리 불변의 특성이 있다. 그렇기 때문에 상단 쿼리문을 실행하면 출력이 되지 않는다.

다음과 같이 문제되는 구간을 주석 처리 후 실행하면 정상적으로 실행되는 점 또한 확인할 수 있다.

DECLARE
    VD_START_VALUE NUMBER(10) DEFAULT 100;

BEGIN
    DBMS_OUTPUT.PUT_LINE('VD_START_VALUE : ' || VD_START_VALUE);

    VD_START_VALUE := 200;
    DBMS_OUTPUT.PUT_LINE('VD_START_VALUE : ' || VD_START_VALUE);

END;
/

상단의 쿼리문은 DEFALUT라는 키워드를 사용한 PL/SQL문이다. 다음과 같이 DEFAULT 키워드를 사용해서 변수를 선언하면 별도의 값 또는 식의 대입이 없어도 기본적으로 설정해둔 값이 대입 및 활용가능하도록 설정할 수 있다. 또한 중간에 별도로 변수 안에 값을 임의로 대입할 수도 있다.

DECLARE
    VNNL_REQUIRED_VALUE VARCHAR2(100) NOT NULL := 'NOT NULL VALUE';

BEGIN
    DBMS_OUTPUT.PUT_LINE('VNNL_REQUIRED_VALUE : ' || VNNL_REQUIRED_VALUE);

END;
/

상단의 쿼리문 NOT NULL 키워드를 사용하여 변수 안에 반드시 값이 존재하도록 규정한 쿼리문이다. 실행해보면 이미지처럼 출력문이 정상적으로 출력되는 점을 확인할 수 있다.

DECLARE
    VNNL_REQUIRED_VALUE VARCHAR2(100) NOT NULL := 'NOT NULL VALUE';

BEGIN
    VNNL_REQUIRED_VALUE := '';
    DBMS_OUTPUT.PUT_LINE('VD_START_VALUE : ' || VNNL_REQUIRED_VALUE);

END;
/

상단 쿼리문을 실행하면 ORA-06502: PL/SQL: 수치 또는 값 오류 라는 알림이 발생하면서 쿼리문이 실행되지 않는다.

이러한 오류가 발생하는 이유는 NOT NULL이라는 키워드를 설정해두면 설정해둔 변수 안에는 반드시 값이 있도록 제어되기 때문이다. 그렇기 때문에 '' 처럼 빈 값이 설정되어있으면 오류가 발생하는 점을 확인할 수 있다.

DECLARE
    V_STU_NAME STUDENT_INFO.STU_NAME%TYPE := '홍길동';

BEGIN
    DBMS_OUTPUT.PUT_LINE('V_STU_NAME : ' || V_STU_NAME);

END;
/

다음과 같이 기존 테이블 내 칼럼이 가지고 있는 자료형을 기반으로 변수를 선언하고 값을 대입할 수도 있다.

형식은 [변수명] [테이블명.칼럼명]%TYPE := [값 또는 식]; 이며 VARCHAR2(), DATE와 같이 스칼라형으로 선언하는 것처럼 PL/SQL문을 작성할 수 있다.

DECLARE
    V_STUDENT STUDENT_INFO%ROWTYPE;

BEGIN
    SELECT * INTO V_STUDENT
      FROM STUDENT_INFO
     WHERE STU_NAME = '홍길동';

    DBMS_OUTPUT.PUT_LINE('V_STUDENT.STU_NUM : ' || V_STUDENT.STU_NUM);
    DBMS_OUTPUT.PUT_LINE('V_STUDENT.STU_NAME : ' || V_STUDENT.STU_NAME);
    DBMS_OUTPUT.PUT_LINE('V_STUDENT.STU_DEPT : ' || V_STUDENT.STU_DEPT);

END;
/

이전에는 테이블 내 칼럼명이 가지고 있는 자료형을 참조하는 방식으로 변수를 선언했다면 상단 쿼리문에는 테이블 전체를 참조해서 변수를 선언하고 활용할 수 있다. 형식은 [변수명] [테이블명]%ROWTYPE이며 ROWTYPE을 통해 특정 테이블에서 각각의 열 하나가 아닌 행 전체를 참조하는 방식으로 진행된다. 쿼리문을 보면 BEGIN 문 바로 하단에 SELECT문이 있는데 * (또는 칼럼명) 옆에 INTO 키워드와 변수명이 있는데 이는 SELECT 문 실행을 통한 결과를 변수에 대입시키는 역할을 하고 있다. 출력문에다 변수명.칼럼명을 입력 후 실행하면 쿼리문에 대한 결과를 확인할 수 있다.

- 조건 제어문

IF 조건문 : IF-THEN, IF-THEN-ELSE, IF-THEN-ELSIF
CASE 조건문 : 단순 CASE문, 검색 CASE문

상단의 이미지는 IF 조건문의 세 가지 종류에 대한 형식을 설명해주고 있다.

DECLARE
    V_STUDENT STUDENT_INFO%ROWTYPE;

BEGIN
    SELECT * INTO V_STUDENT
      FROM STUDENT_INFO
     WHERE STU_NAME = '홍길동';

    DBMS_OUTPUT.PUT_LINE(V_STUDENT.STU_NAME || ' 학생은 ' || V_STUDENT.STU_GRADE || '학년입니다.');
    IF V_STUDENT.STU_GRADE = '1' THEN
        DBMS_OUTPUT.PUT_LINE('신입생');
    ELSIF V_STUDENT.STU_GRADE = '4' THEN
        DBMS_OUTPUT.PUT_LINE('졸업예정자');
    ELSE
        DBMS_OUTPUT.PUT_LINE('일반 재학생');
    END IF;

END;
/

상단의 쿼리문은 IF-THEN-ELSIF문을 활용해서 작성한 PL/SQL문이다. 해당 쿼리문을 실행해보면 홍길동 학생은 2학년이기 때문에 어느 조건문에도 해당되지 않으므로 ELSE문으로 이동하게 되며 일반 재학생이라고 출력될 것이다.

좌측의 CASE문은 값으로만 진위여부를 판단하는 단순 CASE문이며 우측은 조건식을 통한 진위여부를 판단하는 검색 CASE문이다. 전반적인 구조 내지 형식은 거의 동일하며 달라진 점이 있다면 WHEN과 THEN 사이에 들어가는 것이 단순한 값인지 조건식인지에 대한 차이와 CASE 옆에 비교 기준이 존재하는지에 대한 차이가 존재한다.

DECLARE
    V_STUDENT STUDENT_INFO%ROWTYPE;

BEGIN
    SELECT * INTO V_STUDENT
      FROM STUDENT_INFO
     WHERE STU_NAME = '홍길동';

    DBMS_OUTPUT.PUT_LINE(V_STUDENT.STU_NAME || ' 학생은 ' || V_STUDENT.STU_GRADE || '학년입니다.');

    CASE V_STUDENT.STU_GRADE
        WHEN 1 THEN DBMS_OUTPUT.PUT_LINE('신입생입니다.');
        WHEN 4 THEN DBMS_OUTPUT.PUT_LINE('졸업예정자입니다.');
        ELSE DBMS_OUTPUT.PUT_LINE('일반 재학생입니다.');
    END CASE;
    
END;
/

상단의 쿼리문은 WHEN 옆에 단순 값을 활용해서 작성한 단순 CASE PL/SQL 문이다.

DECLARE
    V_STUDENT STUDENT_INFO%ROWTYPE;

BEGIN
    SELECT * INTO V_STUDENT
      FROM STUDENT_INFO
     WHERE STU_NAME = '홍길동';

    DBMS_OUTPUT.PUT_LINE(V_STUDENT.STU_NAME || ' 학생은 ' || V_STUDENT.STU_GRADE || '학년입니다.');

    CASE
        WHEN V_STUDENT.STU_GRADE = 1 THEN DBMS_OUTPUT.PUT_LINE('신입생입니다.');
        WHEN V_STUDENT.STU_GRADE < 4 OR V_STUDENT.STU_GRADE >= 2 THEN DBMS_OUTPUT.PUT_LINE('일반 재학생입니다.');
        ELSE DBMS_OUTPUT.PUT_LINE('졸업예정자입니다.');
    END CASE;

END;
/

다음 쿼리문은 조건식을 활용한 검색 CASE문을 활용한 PL/SQL문이다. 상단 두 개에 대한 출력 결과는 모두 동일하다.

- 반복 제어문 (LOOP)

BASIC LOOP : 기본 반복문
WHILE LOOP : 조건식에 대한 결과를 기반으로 반복 수행
FOR LOOP : 반복 횟수를 지정하여 반복 수행
CUSOR FOR LOOP : 커서를 활용한 반복 수행
EXIT : 수행 중인 반복 종료
EXIT-WHEN : 조건식에 만족할 때 반복 종료
CONTINUE : 수행 중인 반복의 현재 주기 생략
CONTINUE-WHEN : 조건식에 만족할 때 현재 반복 주기 생략

반복 제어문에 대한 전반적인 문법 구조는 상단의 이미지와 같다.

DECLARE
    V_NUM NUMBER(10) := 0;

BEGIN
    LOOP
        DBMS_OUTPUT.PUT_LINE(V_NUM);
        V_NUM := V_NUM + 1;

        EXIT WHEN V_NUM > 10; -- 반복을 멈추는 시점 설정
    END LOOP;

END;
/

상단의 쿼리문은 단순 LOOP문을 활용한 PL/SQL문이다. 해당 쿼리문을 실행해보면 이미지처럼 0부터 10까지 반복문이 실행되는 점을 확인할 수 있다. 이때 EXIT WHEN 키워드를 사용해서 반복문을 종료하는 시점을 설정해서 10까지만 반복하고 종료하도록 설정되어있는 점을 확인할 수 있다. IF THEN 문을 사용해서도 반복문의 종료시점을 설정할 수 있다.

DECLARE
    V_NUM NUMBER(10) := 0;

BEGIN
    WHILE V_NUM <= 10 LOOP
        DBMS_OUTPUT.PUT_LINE(V_NUM);
        V_NUM := V_NUM + 1;
    END LOOP;

END;
/

다음은 WHILE LOOP를 사용해서 작성한 쿼리문이다. 출력 결과는 상단의 단순 LOOP문과 동일하다. 해당 쿼리문을 살펴보면 WHILE와 LOOP 사이에 조건식을 작성해서 반복문을 구현하는 방식이며 V_NUM <= 10을 통해 V_NUM의 값이 10이 될 때까지 내부 로직을 반복해서 실행하겠다는 점을 확인할 수 있다.

DECLARE

BEGIN
    FOR i IN 0 .. 10 LOOP
        DBMS_OUTPUT.PUT_LINE(i);
    END LOOP;

END;
/

상단의 쿼리문은 FOR LOOP문을 활용해서 반복문을 작성한 PL/SQL문이다. 해당 건의 결과는 상단의 두 개의 쿼리문과 동일하다. 해당 쿼리문을 보면 프로그래밍 언어와 거의 비슷한 구조를 지니고 있으며 0부터 10까지 반복하다가 반복문을 종료하고 있다는 점을 볼 수 있다.

DECLARE
BEGIN
    FOR i IN 0 .. 10 LOOP
        CONTINUE WHEN i = 2 OR i = 5;
        DBMS_OUTPUT.PUT_LINE(i);
    END LOOP;

END;
/

상단 쿼리문은 FOR LOOP안에 CONTINUE WHEN을 활용해서 특정 조건에서 반복 내지 출력을 생략하는 PL/SQL문이다. 쿼리문을 실행해보면 상단 이미지처럼 특정 조건에 달성한 경우에만 출력을 생략하고 그 외에는 그대로 출력해주는 것을 확인할 수 있다. CONTINUE WHEN 뒤에 i = 2 OR i = 5라고 되어있는데 이는 i의 값이 2 또는 5일 때 건너뛴다는 뜻이다.

[SQL] 제약 조건

Untitled_Blue — Mon, 6 May 2024 02:25:50 +0900

안녕하세요. 이번 글은 제약조건에 대한 설명입니다.

- 제약 조건이란?

테이블 내 특정 칼럼에 조건에 부합하지 않는 값을 입력할 수 없도록 하는 조건
대표적으로 NOT NULL, CHECK, PRIMARY KEY, FORGEIN KEY, UNIQUE가 있다.

- 제약 조건 정보를 모두 볼 수 있는 테이블

SELECT * FROM USER_CONSTRAINTS;

USER_CONSTRAINTS 테이블은 현재 로그인하고 있는 계정에 존재하는 모든 테이블의 제약 조건을 보여주고 있다.

칼럼명	설명
OWNER	제약 조건의 소유자
CONSTRAINT_NAME	제약 조건의 명칭 (별도의 지정이 없으면 임의값 배정)
CONSTRAINT_TYPE	제약 조건 타입 (C : CHECK, NOT NULL, U : UNIQUE, P : Primary Key, R : Foreign Key)
TABLE_NAME	제약 조건이 명시되어있는 테이블명

상단의 이미지는 테이블 생성하는 쿼리문이며 제약 조건의 종류와 제약 조건의 명칭을 지정할 수 있다는 점을 확인할 수 있다. 학번인 STU_NUM은 기본키로 설정하였으며 성별 정보를 담는 STU_GENDER는 CHECK를 통해 남자와 여자 두 개의 데이터만 담을 수 있도록 제한한 점을 확인할 수 있으며 나머지는 NOT NULL을 통해 빈 값을 허용하지 않도록 두었다.

STU_NAME VARCHAR2(300) NOT NULL CONSTRAINT STU_INFO_NAME_NN

다음과 같이 [칼럼명] [데이터타입] [제약조건] CONSTRAINT [제약조건명]을 통해 테이블 생성과 동시에 제약 조건을 설정할 수 있다. 데이터 생성 이후에 USER_CONSTRAINTS 테이블 뒤에 TABLE_NAME = '[테이블명]'을 붙이고 쿼리문을 실행하면 생성한 테이블에 대한 모든 제약 조건에 대한 정보를 확인할 수 있다.

ALTER TABLE STUDENT_INFO 
     MODIFY (STU_DEPT NULL);

상단의 쿼리문은 테이블 내의 칼럼에 대해서 제약 조건을 변경하는 쿼리문이다. 제약 조건을 기존 NOT NULL에서 NULL로 변경하라는 뜻을 가지고 있다. 해당 쿼리문을 실행하면 제약 조건을 무리없이 바꿀 수 있지만 반대로 NULL에서 NOT NULL로 변경하려고 할 때는 다를 수 있다. 왜냐하면 기존에 테이블에 저장되어 있는 데이터 중에 NULL값이 하나라도 있다면 변경하려는 NOT NULL이라는 제약 조건에 위배된다는 점에서 변경이 안되는 경우가 존재하기 때문이다. 그렇기 때문에 제약 조건은 가급적이면 처음 테이블을 생성할 때 계획하고 지정하는 것을 권장한다. 물론 기존 NULL이었던 데이터를 빈 값이 없도록 수정한 후에 제약 조건을 수정할 수 있다.

ALTER TABLE STUDENT_INFO RENAME CONSTRAINT STU_INFO_ACA_NN TO STU_INFO_STATUS_NN;

상단의 쿼리문은 테이블 내 기존 제약조건명을 다른 이름으로 새롭게 수정하는 역할을 담당하고 있다. 쿼리문 형식은 ALTER TABLE [테이블명] RENAME CONSTRAINT [기존명칭] TO [새명칭]이다.

해당 쿼리문 실행 후 USER_ CONSTRAINTS 테이블을 조회하면 정상적으로 명칭이 변경된 점을 확인할 수 있다.

ALTER TABLE STUDENT_INFO DROP CONSTRAINT STU_INFO_STATUS_NN;

상단 쿼리문을 통해 기존에 지정되어 있던 테이블 내 제약조건을 삭제할 수 있다.

- 빈 값은 허용하지 않는다. NOT NULL

INSERT INTO STUDENT_INFO VALUES ('이땡땡', '20240101', '1', '예술디자인대학', '서양화과', NULL ,'남자');

상단에서 언급했던 STUDENT_INFO 테이블에 STU_ACA이라는 칼럼에 값을 넣지 않은 상태로 상단 쿼리문을 실행하면 ORA-01400: NULL을 ("SCOTT"."STUDENT_INFO"."STU_ACA") 안에 삽입할 수 없습니다 라는 알림창과 함께 테이블에 데이터가 입력되지 않는 점을 확인할 수 있다. 왜냐하면 STU_ACA는 NOT NULL이라는 제약 조건이 존재하기 때문에 빈 값을 허용하지 않기 때문이다. 이렇듯 NOT NULL은 빈 값이 삽입되는 것을 허용하지 않는다는 점을 알 수 있다.

- 빈 값은 허용해도 중복값은 허용하지 않는다. UNIQUE

SELECT * FROM TABLE_UNIQUE;

상단의 TABLE_UNIQUE 테이블의 스크립트를 보면 LOGIN_ID라는 칼럼의 제약 조건이 UNIQUE로 설정되어 있는 점을 확인할 수 있다. UNIQUE는 NULL은 값 자체가 없기 때문에 여러 개 있어도 무방하나 데이터의 중복을 허용하지 않는다.

INSERT INTO TABLE_UNIQUE VALUES ('TEST_ID_02', '1111', '02-1111-1111');

상단의 쿼리문을 실행하면 ORA-00001: 무결성 제약 조건(SCOTT.SYS_C007645)에 위배됩니다 라는 알림이 발생하는 점을 확인할 수 있는데 이러한 알림이 발생하는 이유는 중복된 값을 허용하지 않는 제약 조건을 위배했기 때문이다. 이렇듯 UNIQUE 제약조건은 중복된 데이터를 허용하지 않는다는 점을 확인할 수 있다.

- 지정해둔 값만 저장할 수 있다. Check

INSERT INTO STUDENT_INFO VALUES ('김땡땡', '20240101', '1', '인문대학', '문헌정보학과', '재학', '남성');

다음과 같이 쿼리문을 입력 후 실행하면 ORA-02290: 체크 제약조건(SCOTT.STU_INFO_GENDER_CK)이 위배되었습니다 라는 알림을 확인할 수 있을 것이다. 이러한 알림이 발생한 이유는 STU_GENDER라는 칼럼에 CHECK 라는 제약 조건이 있는데 여기에는 남자 또는 여자라는 값만 들어오는 것을 허가하고 그 외 값은 삽입되지 않도록 제한되어있기 때문이다.이렇게 지정된 값 외에 다른 값들은 삽입되지 않도록 규정하는 제약 조건을 CHECK라고 한다.

- NOT NULL + UNIQUE = Primary Key

SELECT * FROM USER_CONSTRAINTS WHERE TABLE_NAME = 'TABLE_PK';

TABLE_PK라는 테이블의 제약 조건을 보면 다음과 같이 P 라는 타입이 있는 점을 통해 내부에 기본키가 지정되어 있는 점을 확인할 수 있다. 기본키는 일종의 고유번호로서 유일성과 최소성을 가졌다는 점이 특징이다. NULL값이어도 안되며 기존 데이터와 중복되서도 안된다는 뜻이다.

INSERT INTO TABLE_PK VALUES ('TEST_ID_02', 'PWD02', '010-1111-1111');

다음과 같은 쿼리문을 실행하면 ORA-00001: 무결성 제약 조건(SCOTT.SYS_C007650)에 위배됩니다 라는 알림이 발생하는 점을 확인할 수 있다. 해당 알림이 발생하는 이유는 중복 데이터라는 점에서 제약 조건을 위배했기 때문이다.

INSERT INTO TABLE_PK VALUES (NULL, 'PWD02', '010-1111-1111');

상단의 쿼리문을 실행하면 NULL을 ("SCOTT"."TABLE_PK"."LOGIN_ID") 안에 삽입할 수 없습니다 라는 알림이 발생하는데 이는 빈 값이라는 점에서 제약 조건을 위배했기 때문에 데이터가 들어가지 않는다는 점을 확인할 수 있으며 상단의 두 개의 쿼리문을 통해 TABLE_PK 내 LOGIN_ID라는 칼럼이 기본키라는 점을 확인할 수 있다.

- 다른 테이블을 참조하고 연결하는 Foreign Key

SELECT * FROM USER_CONSTRAINTS WHERE TABLE_NAME IN ('DEPT_FK', 'EMP_FK');

외래키는 서로 다른 테이블과의 관계를 정의할 때 사용하는 제약조건이며 특정 테이블의 기본키를 다른 테이블의 특정 칼럼에서 본인들의 테이블을 다룰 때 참조하겠다는 의미를 담고 있다. 상단의 쿼리문을 실행해보면 EMP_FK와 DEPT_FK 테이블의 제약 조건에 대한 정보를 확인할 수 있는데 이때 CONSTRAINT_TYPE와 R_CONSTRAINT_NAME이라는 칼럼을 주목해보자. CONSTRAINT_TYPE이 R인 점을 봐서 외래키라는 점을 확인할 수 있으며 DEPTFK_DEPTNO_PK가 DEPT_FK 테이블의 기본키라는 점을 보면 두 테이블 간의 연결 관계가 존재한다는 점과 EMP_FK는 DEPT_FK를 참조하고 있다는 점을 알 수 있다.

SELECT * FROM EMP_FK;

SELECT * FROM DEPT_FK;

상단 두 개의 테이블을 봤을 때 공통적인 칼럼 DEPTNO를 확인할 수 있으며 또한 참조관계를 보면 EMP_FK에서 DEPTNO 칼럼을 추가할 때는 무조건 DEPT_FK 테이블을 참조하도록 되어있다. 이를 통해 EMP_FK 테이블에서는 DEPT_FK 내 DEPTNO에 저장되어 있는 값만을 저장할 수 있으며 DEPT_FK에 없는 데이터는 EMP_FK에서 저장할 수 없다는 점을 확인할 수 있다.

INSERT INTO EMP_FK VALUES ('1234', 'BLUE', 'CLERK', '5678', SYSDATE, 2800, NULL, 20);

해당 쿼리문을 실행해보면 ORA-02291: 무결성 제약조건(SCOTT.EMPFK_DEPTNO_FK)이 위배되었습니다- 부모 키가 없습니다 라는 알림을 확인할 수 있는데 이는 참조되고 있는 테이블 내에 해당되는 데이터가 없기 때문에 발생한 것이다.

INSERT INTO EMP_FK VALUES ('1234', 'BLUE', 'CLERK', '5678', SYSDATE, 2800, NULL, 10);

상단의 쿼리문 같이 DEPT_FK에 있는 데이터를 확인해서 실행하면 상단 이미지처럼 정상적으로 데이터가 입력된 점을 확인할 수 있다.

CONSTRAINT EMPFK_DEPTNO_FK REFERENCES DEPT_FK (DEPTNO)

다음과 같이 CONSTRAINT [제약조건명] REFERENCES [참조 대상 테이블] ([참조 칼럼])을 통해 테이블을 생성할 때 참조할 테이블을 바탕으로 외래키를 설정할 수 있는 점 확인할 수 있다.

DELETE FROM DEPT_FK WHERE DEPTNO = '10';

다음과 같이 두 개의 테이블은 참조 관계를 가지고 있는데 부모 테이블인 DEPT_FK에 있는 값을 자식 테이블인 EMP_FK에서 참조해서 사용하고 있는 상태이다. 이러한 상황에서 상단 쿼리문을 실행하면 ORA-02292: 무결성 제약조건(SCOTT.EMPFK_DEPTNO_FK)이 위배되었습니다- 자식 레코드가 발견되었습니다 이라는 알림이 발생하는 것을 볼 수 있다. 참조 관계의 테이블 사이에서 자식 테이블이 부모 테이블의 데이터를 참조한 건이 하나라도 있으면 삭제할 수 없다.

그럼에도 불구하고 삭제해야된다고 하면 자식 테이블인 EMP_FK에서의 참조하고 있는 행에 대해서 데이터를 수정 또는 삭제하거나 부모 테이블 내 데이터를 제거하면서 참조하고 있는 자식 테이블의 데이터도 함께 지워야 한다.

후자의 방법을 사용하려면 하단의 방법을 사용해야 한다.

CONSTRAINT [제약조건명] REFERENCES [참조 대상 테이블]([참조 칼럼]) ON DELETE CASCADE
CONSTRAINT [제약조건명] REFERENCES [참조 대상 테이블]([참조 칼럼]) ON DELETE SET NULL

첫 번째부터 보면 부모 테이블에서 데이터 삭제 시 해당 값을 참조하고 있는 자식 테이블의 데이터도 함께 삭제되도록 설정하는 것이며 두 번째는 부모 테이블 데이터 삭제 시 참조하고 있는 자식 테이블의 데이터는 NULL값으로 변경하도록 설정하는 것이다. 데이터를 최대한 보존하는 방향으로 가야되면 두 번째 방법을 사용하는 것이 좋다.

- 빈 값이면 기본 값으로 자동 삽입한다. Default

다음은 DEFAULT 제약 조건인데 상단의 쿼리문처럼 뒤에 DEFAULT [기본값]을 통해 특정 칼럼에 별도로 값을 지정하지 않으면 설정해둔 값이 자동으로 삽입될 수 있도록 설정할 수 있다.

INSERT INTO TABLE_DEFAULT (LOGIN_ID, TEL) VALUES ('TEST_ID2', '010-1234-5678');

다음과 같이 LOGIN_PWD에 아무런 값없이 INSERT문을 실행하면 오류 발생없이 기본값으로 설정해둔 값이 정상적으로 들어가있는 점을 확인할 수 있다.