34일차 sqlcl 설정과 sql문 아주 조금 그리고 제네릭 정리

쿠우·2022년 5월 12일
0

로그인에 대한 정보의 형식을 담고있는 파일로 시작!

해당 경로로 환경변수 설정해준다.

DB를 알아내는 경로와 DB이름

DB접속 명령어와 유저정보 보는 법

권한부여하는 과정입니다

log를 어디다 받을 지 설정하고 각각의 아이디와 패스워드를 설정
@mksample 명령어를 입력하고 이후에 아래 내용에 맞춰서 값을 입력해준다.

specify password for ADMIN as parameter 1:
  1에 대한 값 입력: Oracle12345678
  specify password for HR as parameter 2:
  2에 대한 값 입력: Oracle12345678
  specify password for OE as parameter 3:
  3에 대한 값 입력: Oracle12345678
  specify password for PM as parameter 4:
  4에 대한 값 입력: Oracle12345678
  specify password for IX as parameter 5:
  5에 대한 값 입력: Oracle12345678
  specify password for SH as parameter 6:
  6에 대한 값 입력: Oracle12345678
  specify password for BI as parameter 7:
  7에 대한 값 입력: Oracle12345678
  specify default tablespace as parameter 8:
  8에 대한 값 입력: USERS
  specify temporary tablespace as parameter 9:
  9에 대한 값 입력: TEMP
  specify log file directory (including trailing delimiter) as parameter 10:
  10에 대한 값 입력: C:\Temp\log
  specify connect string as parameter 11:
  11에 대한 값 입력: db20220510181319_high

그리고 VSCODE로 옮겨서

아까 설정한 각각에 아이디에 계정을 만들 수있다. 주로 HR계정을 이용한다.

SCOTT 계정을 설정한다.
아래 구문은 ADMIN 계정에서 계정을 만들 수 있는 권한을 부여해준다.
쿼리문을 만들어 실행시켜준다.

GRANT CONNECT,RESOURCE,UNLIMITED TABLESPACE TO SCOTT IDENTIFIED BY Oracle12345678;
ALTER USER SCOTT DEFAULT TABLESPACE USERS;
ALTER USER SCOTT TEMPORARY TABLESPACE TEMP;

SCOTT 계정이 생성된 후
아래구문을 스캇계정의 쿼리문에서 실행해주면
테이블이 추가 된다!

DROP TABLE DEPT;
CREATE TABLE DEPT
       (DEPTNO NUMBER(2) CONSTRAINT PK_DEPT PRIMARY KEY,
   DNAME VARCHAR2(14) ,
   LOC VARCHAR2(13) ) ;
DROP TABLE EMP;
CREATE TABLE EMP
       (EMPNO NUMBER(4) CONSTRAINT PK_EMP PRIMARY KEY,
   ENAME VARCHAR2(10),
   JOB VARCHAR2(9),
   MGR NUMBER(4),
   HIREDATE DATE,
   SAL NUMBER(7,2),
   COMM NUMBER(7,2),
   DEPTNO NUMBER(2) CONSTRAINT FK_DEPTNO REFERENCES DEPT);
INSERT INTO DEPT VALUES
   (10,'ACCOUNTING','NEW YORK');
INSERT INTO DEPT VALUES (20,'RESEARCH','DALLAS');
INSERT INTO DEPT VALUES
   (30,'SALES','CHICAGO');
INSERT INTO DEPT VALUES
   (40,'OPERATIONS','BOSTON');
INSERT INTO EMP VALUES
(7369,'SMITH','CLERK',7902,to_date('17-12-1980','dd-mm-yyyy'),800,NULL,20);
INSERT INTO EMP VALUES
(7499,'ALLEN','SALESMAN',7698,to_date('20-2-1981','dd-mm-yyyy'),1600,300,30);
INSERT INTO EMP VALUES
(7521,'WARD','SALESMAN',7698,to_date('22-2-1981','dd-mm-yyyy'),1250,500,30);
INSERT INTO EMP VALUES
(7566,'JONES','MANAGER',7839,to_date('2-4-1981','dd-mm-yyyy'),2975,NULL,20);
INSERT INTO EMP VALUES
(7654,'MARTIN','SALESMAN',7698,to_date('28-9-1981','dd-mm-yyyy'),1250,1400,30);
INSERT INTO EMP VALUES
(7698,'BLAKE','MANAGER',7839,to_date('1-5-1981','dd-mm-yyyy'),2850,NULL,30);
INSERT INTO EMP VALUES
(7782,'CLARK','MANAGER',7839,to_date('9-6-1981','dd-mm-yyyy'),2450,NULL,10);
INSERT INTO EMP VALUES
(7788,'SCOTT','ANALYST',7566,to_date('13-JUL-87')-85,3000,NULL,20);
INSERT INTO EMP VALUES
(7839,'KING','PRESIDENT',NULL,to_date('17-11-1981','dd-mm-yyyy'),5000,NULL,10);
INSERT INTO EMP VALUES
(7844,'TURNER','SALESMAN',7698,to_date('8-9-1981','dd-mm-yyyy'),1500,0,30);
INSERT INTO EMP VALUES
(7876,'ADAMS','CLERK',7788,to_date('13-JUL-87')-51,1100,NULL,20);
INSERT INTO EMP VALUES
(7900,'JAMES','CLERK',7698,to_date('3-12-1981','dd-mm-yyyy'),950,NULL,30);
INSERT INTO EMP VALUES
(7902,'FORD','ANALYST',7566,to_date('3-12-1981','dd-mm-yyyy'),3000,NULL,20);
INSERT INTO EMP VALUES
(7934,'MILLER','CLERK',7782,to_date('23-1-1982','dd-mm-yyyy'),1300,NULL,10);
DROP TABLE BONUS;
CREATE TABLE BONUS
   (
   ENAME VARCHAR2(10)   ,
   JOB VARCHAR2(9)  ,
   SAL NUMBER,
   COMM NUMBER
   ) ;
DROP TABLE SALGRADE;
CREATE TABLE SALGRADE
      ( GRADE NUMBER,
   LOSAL NUMBER,
   HISAL NUMBER );
INSERT INTO SALGRADE VALUES (1,700,1200);
INSERT INTO SALGRADE VALUES (2,1201,1400);
INSERT INTO SALGRADE VALUES (3,1401,2000);
INSERT INTO SALGRADE VALUES (4,2001,3000);
INSERT INTO SALGRADE VALUES (5,3001,9999);
COMMIT;
SET TERMOUT ON
SET ECHO ON

-developer에서 HR계정과 SCOTT계정 생성
같은 방식으로 하면된다. 워크시트에서 엑스큐트해서


SQL => Structured Query Language (구조화된 질의언어)
=> "내가 정한 조건에 맞는 데이터를 달라!!"

만들 수 있는 SQL문장의 종류(5가지):
(1) DQL - Data Query Language (조회쿼리)
(2) DML - Data Manipulation Language (조작쿼리)
(3) DDL - Data Definition Language (DB객체 CRUD like Table)
(4) DCL - Data Control Language (데이터에 대한 접근권한제어, 사용자 계정 CRUD)
(5) TCL - Transaction Control Language (트랜잭션 제어 언어

중요한거 오늘 SELECT문 순서까지는 반드시 알아야한다


제네릭

-제네릭을 사용하는 코드의 이점

(1)컴파일 시 강한 타입 체크 가능

실행 시 타입 에러가 나는 것 방지
컴파일 시에 미리 타입을 강하게 체크해서 에러 사전 방지

(2)타입변환 제거 가능

-제네릭 타입이란?

(1)타입을 파라미터로 가지는 클래스와 인터페이스

(2)선언 시 클래스 또는 인터페이스 이름 뒤에 “<>” 부호 붙임

(3)“<>” 사이에는 타입 파라미터 위치

(4)타입 파라미터

일반적으로 대문자 알파벳 한 문자로 표현
개발 코드에서는 타입 파라미터 자리에 구체적인 타입을 지정해야

-제네릭 타입 사용 여부에 따른 비교

(1)제네릭 타입을 사용하지 않은 경우

( Object 타입 사용 > 빈번한 타입 변환 발생 > 프로그램 성능 저하)

(2)제네릭 타입 사용한 경우

(클래스 선언할 때 타입 파라미터 사용)
(컴파일 시 타입 파라미터가 구체적인 클래스로 변경)

-멀티 타입 파라미터

제네릭 타입은 두 개 이상의 타입 파라미터 사용 가능
(각 타입 파라미터는 콤마로 구분)
(자바 7부터는 다이아몬드 연산자 사용해 간단히 작성과 사용 가능)

-------------------------<목업클래스>-------------------
package ex1;

public class Car { // Mock - up class
	;;
}// end class
-------------------------<목업클래스>-------------------
package ex1;

// 아무것도 없는 껍데기 클래스를 Mock - up 클래스라고 한다 .
public class Tv { // Mock - up class
	;;
}// end class
---------------------------<제네릭클래스 선언>-----------------------
//제네릭 타입중, "제네릭 클래스"를 선언 => 타입 파라미터를 선언 
@ToString
@Setter
@Getter
@NoArgsConstructor
public class Product<T,M> { // 다중 (멀티) 타입 파라미터를 가지고 있다.
	private T kind; 
	private M model; 
	
}// end class
-------------------------<제네릭 클래스 사용>-------------------------
public class ProductEx {

	
	public static void main(String[] args) {
		// 1. 제네릭 클래스 product 타입의 객체 생성 -- > "사용"
		//  So, 타입파라미터 T -> 구체타입으로 "TV" 를 전달 
		//      타입파라미터 M -> 구체타입으로 "String"을 전달
//		Product<Tv, String> product1 = new Product<Tv,String>(); @until 7
		
		// <>다이아몬드 연산자 : 타입추론 연산자 
		Product<Tv, String> product1 = new Product<>(); // @since 8
		
		product1.setKind(new Tv());
		product1.setModel("스마트TV");
		Tv tv = product1.getKind();
		String tvModel = product1.getModel();
		
		System.out.println(product1);
		
		
		
//		----- 
		
		Product<Car, String> product2 = new Product<Car,String>();
		
		product2.setKind(new Car());
		product2.setModel("SONATA");
		Car car = product2.getKind();
		String CarModel = product2.getModel();
		
		System.out.println(product2);
		
		
		
	}// main

}// end class

제네릭 타입의 종류 3가지
(1) 제네릭 클래스
(2) 제네릭 인터페이스
(3) 제네릭 메소드

*제네릭 타입 파라미터에, "구체적인 참조타입(=구체타입)"을 언제지정해야 되느냐!?

1))) 제네릭 타입(=클래스/인터페이스/메소드) "선언할 때"에는,
타입파라미터 T, U, R, ...... 를 단문자로 표시

2))) 제네릭 타입을 "사용"할 때, "구체타입 지정" (*)
-new 연산자로, 제네릭타입의 "객체를 생성할 때"

-제네릭 타입을 메소드/생성자의 매개변수의 타입으로 지정(선언)할 때!
ex) String name = "Yoseph";

3))) 제네릭 메소드를 호출할 때, "구체타입명을 인자로 전달"

선언과 사용을 구별해야한다.
타입과 메소드의 제네릭을 구별해야한다.


제네릭 메소드

(1)매개변수 타입과 리턴 타입으로 타입 파라미터를 갖는 메소드
(2)제네릭 메소드 선언 방법
(3)제네릭 메소드 호출하는 두 가지 방법
ㄱ)명시적으로 구체적 타입을 지정하거나
ㄴ)매개(인자)값을 보고 구체적타입을 추정한다.

제네릭메소드 예제코드 1

---------------------<재네릭클래스선언>---------------------
@ToString
@NoArgsConstructor
// 제네릭 타입 파라미터 T를 가지는, 제네릭 클래스를 "선언" 
public class Box<T> {
	private T t;
	
	public T get() {return t;}
	public void set(T t) {this.t = t;}
}// end class 
-----------------------<제네릭 메소드 선언>-----------------------
public class Util {

	//타입파라미터 <T>는 반환타입 앞에 있어야함	
	public static <T> Box<T> boxing(T t){
		Box<T> box = new Box<T>();
		box.set(t);
		return box;
	}// boxing
	
	

//	public static  Box boxing(T t){
//		//제네릭 클래스를 "사용"해서 객체를 생성하기 때문에 
//		// "구체타입"을 전달
//		Box box = new Box();
//		box.set(t);
//		
//		return box;
//	}// boxing
	
} // end class
-----------------------<제네릭 클래스,메소드 사용>-----------------------
	public static void main(String[] args) {
		// 제네릭 메소드를 호출하는 것은, "사용"에 해당->따라서 '구체타입지정'
		Box<Integer> box1 = Util.<Integer>boxing(100);
		int intValue = box1.get();
		
		System.out.println(box1);
//		----
		// 사실 생략 가능하다. 인자값을 읽어서 구체타입을 예측한다. 
		Box<String> box2 = Util.boxing("홍길동");
		String strValue = box2.get();
		
		System.out.println(box2);
		
	}// main 

}// end class

제네릭메소드 예제코드 2

-----------------<제네릭 메소드 선언>-------------------------
package ex3;

public class Util {
	public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
		boolean keyCompare = p1.getKey().equals(p2.getKey()) ;
		boolean valueCompare = p1.getValue().equals(p2.getValue());
	    return keyCompare && valueCompare;
	}
}
-----------------<제네릭 클래스선언>-------------------------
package ex3;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@NoArgsConstructor
@Setter
@Getter
@ToString
public class Pair<K, V> {
	private K key;
	private V value;

	public Pair(K key, V value) {
		this.key = key;
		this.value = value;
	}

	public void setKey(K key) { this.key = key; }
	public void setValue(V value) { this.value = value; }
	public K getKey()   { return key; }
	public V getValue() { return value; }
}
-----------------<제네릭 클래스의  비교>-------------------------
package thisjava;

import ex3.Pair;
import ex3.Util;


public class Ex01 {

	
	public static void main(String[] args) {
		// Generic type class: Pair<K, V>
		Pair<Integer, String> p1 = new Pair<>(1, "사과");
		Pair<Integer, String> p2 = new Pair<>(1, "사과");

		// Generic Method: <T> boolean compare(...)
		boolean result1 =Util.compare(p1, p2);
		
		if(result1) {
			System.out.println("논리적으로 동등한 객체입니다.");
		}else {
			System.out.println("논리적으로 동등하지 않는 객체입니다.");
		}// if- else
		
		
		
		
	} // main 

}// class end

제네릭메소드 다형성 예제코드

----------------------------<가장 조상 클래스>-------------------------
package ex01;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;

@ToString
@AllArgsConstructor
@Getter
public class Person {

	@Getter 
	private String name;
	
	
	
}// end class
----------------------------<자손 클래스>-------------------------
package ex01;

public class Student extends Person {

	public Student(String name) {
		super(name);
	}
	
} // end class
----------------------------<자손의 자손 클래스>-------------------------
package ex01;

public class HighStudent extends Student{
	public HighStudent(String name) {
		super(name);
	}
} // end class
----------------------------<자손 클래스>-------------------------
package ex01;


public class Worker extends Person {
	
	public Worker(String name) {
		super(name);
		
	}// Constructor
	
}//end class
----------------------------<제네릭 클래스 선언>-------------------------
package ex01;

import lombok.Getter;
import lombok.ToString;


@Getter
@ToString
// generic class with only one type parameter.
public class Course<T> {
	
	private String name; // 과정명 
	private T[] students; // 수강생을 관리할 배열 
	
	public Course(String name, int capacity) { // 인스턴스 필드의 초기화 
		this.name = name;
		
		// 타입 파라미터를 원소의 타입으로 가지는 배열객체를 생성하려면 
		// 아래와 같이, 먼저 Object 타입의 배열을 생성한 이후에, 
		// 강제 형변환을 통해, T[] 배열을 만들어야 함(문법)
		students = (T[]) (new Object[capacity]);
	}// constructor 

	// 이 과정에 새로운 수강생을 등록하는 메소드
	public String getName() { return name; }
	public T[] getStudents() { return students; }
	public void add(T t) {
		for(int i=0; i<students.length; i++) {
			if(students[i] == null) {
				students[i] = t;
				
				break;
			}// if
		}// for
	}// add
	
}// end class
-------------------<제네릭 클래스 사용  다형성 확인>-------------------------
package ex01;

public class WildCardExample {
	
	
	

	public static void main(String[] args) {
		
		
		// Generic Class : Course<T>
		Course<Person> personCourse = new Course<Person>("일반인과정", 5); 
		
		// 다형성-1: 부모타입의 참조변수에는, 모든 자식객체가 대입가능하다!!
		// add(T t) => add (Person t)
		personCourse.add(new Person("일반인"));
		personCourse.add(new Worker("직장인"));
		personCourse.add(new Student("학생"));
		personCourse.add(new HighStudent("고등학생"));
		
		System.out.println(personCourse);
		
	}// main 

}//end class
profile
일단 흐자

0개의 댓글