탐욕적인 방법(greedy method) 을 이용하여 

네트워크(가중치를 간선에 할당한 그래프)의 모든 정점을 최소 비용으로 연결하는 최적 해답을 구하는 것

1) cost 기준으로 오름차순 정렬

2) 정렬된 그래프를 기준으로 간선연결

 - 간선은 필요한 간선만 연결
 - 필요한 간선이란? 기 연결된 정점은 해당 간선을 이용해 연결하지 않는다
 즉, 어떤 두 정점이 연결됐는지 안됐는지 확인하는 연산필요 -> union find 이용 
 1) find(a) != find(b) => 연결 (union(a,b))
 2) find(a) = find(b) => 연결 X

 

 

    static long kruskal(int startIdx) {
        initParent();
        for (int i = startIdx; i < M; i++) {
            Edge edge = list.get(i);
            if (find(edge.e) == find(edge.s)) { // 같은 그룹이면 연결 안함
                continue;
            }
            union(edge.s, edge.e); // 다른그룹이므로 연결함
        }
        return -1; // 연결 안되어 있음
    }

대표적 그래프 알고리즘으로 '합집합 찾기'라는 의미를 가지고 있습니다.

상호 배타적 집합(Disjoint-set)이라고도 합니다.

여러 노드가 존재할 때, 두 개의 노드를 선택해서, 현재 두 노드가 서로 같은 그래프에 속하는지 판별하는 알고리즘이다.

 

즉, 그래프에서 같은 그룹에 속하는가? 를 물어볼 수 있는 알고리즘이다.

혹은 그룹을 합치거나

 

 

1. 초기화 ( make set)

자기자신을 부모로 갖도록 초기화 해준다.

int[] parent = new int[N+1];
for(int i = 0 ; i <= N ; i ++){
	parent[i] = i;
}

 

 

2. find

int find(int a){
	if(a == parent[a]) return a;
	return parent[a] = find(parent[a]); // 경로 압축

}

시간복잡도 O(N)

 

원래 return 부가 

return find(parent[a]) 인데 

return parent[a] = find(parent[a]) 로 경로 압축을 해주었다. 한번에 가기~!

 

3. union

void union(int a, int b){
	a = find(a);
	b = find(b);
	
	if(a != b){
		//항상 더 작은수로 부모를 넣어준다.
		if(a > b){ // a가 항상 작은수가 되도록 만듦
              int tmp = a;
              a = b;
              b = tmp;
        }
        parent[b] = a;
	}
}

 

4. 문제 풀기

1. 계속 합쳐지는 패턴 
2. 계속 분리되는 패턴 
 - 질문의 역순으로 답을 내야함 

  => 질문을 미리 저장해두고, 질문의 역순으로 답을 낸다. 

  
3. 그룹의 멤버의 수 
4. 유효/무효 값 분리 

LCA는 트리를 이용해서 최단거리 알고리즘을 구하는 것이다.

최소 공통조상을 구하는 알고리즘이다. Lowest Common Ancestor

 

구현

 

0. dfs or bfs depth , parent[N][K] : N번 노드의 2^K번째 조상 기록


parent[2][0] = 2번 노드의 첫번째 조상
parent[2][1] = 2번 노드의 두번째 조상
parent[2][2] = 2번 노드의 네번째(2^2) 조상

 

dfs로 구현하면 stack이 터질 수 있으니, bfs로 구현하는 것이 좋다.

 

2^K번째 조상을 기록 한다는것이 잘 이해가 안갈 수 있다. 왜 2^K번째 조상을 기록할까? 시간복잡도를 줄이기 위해서이다.

 

다음을 보자. 1에서 12로 이동할때 


이진법으로 움직이면?
1->2->-3->4->5->6->7->8->9->10  ->11         ->12 :  한칸씩 뛰면 11번 이동, 비효율적임
1--------(2^3)---------->9-----(2^1)---->11-(2^0)->12 :  2진법으로 움직이면 3번 이동, 효율적임

 

규칙을보면 다음과 같은 점화식을 얻을 수 있다.

parent[N][K] = parent[parent[N][K-1]][K-1];

A ------------> C                parent[A][4] = C
1               17

A ----- B ----> C                parent[A][3] = B , parent[B][3] = C
1        9        17               parent[A][4] = parent[parent[A][3]][3]

 

 

1. LCA 로직

 1) 양쪽 노드중 깊이가 깊은 것을 끌어올려 깊이를 맞춘다.( 2진법으로 뛸 수 있는 만큼 높이 뛰기)


 2) if(a == b) return a;


 3) else 높이가 맞춰진 양쪽 노드를 동시에 끌어올린다. 

    단 2진법으로 뛸수 있는만큼 뛰는데, ***부모가 다를경우에만 점프

 

 4) return parent[a][0]; // a또는 b의 부모 

 

 

샘플코드

 

BFS

 

    static int MAX =18;
    static int[] depth = new int[MAX];
    static int[][] parent = new int[MAX][32];
    // 2^k = N -> k = logN : parent배열의 열의 사이즈는 logN
    // 2^10 = 10^3 , 2^40 = 2^10^4 = 10^3^4 = 10^12
    // 2^17 = 13만 , 2^18 = 26만 , 2^20 = 104만

    static boolean[] visited = new boolean[MAX];
    static ArrayList<Integer>[] adj = new ArrayList[MAX];
    
    static void bfs(int now) {
        Queue<Integer> q = new ArrayDeque<>();
        q.add(now);

        while (!q.isEmpty()) {
            now = q.poll();
            visited[now] = true;
            for (int next : adj[now]) {
                if (visited[next]) continue;

                parent[next][0] = now;
                for (int j = 1; j < MAX; j++) {
                    parent[next][j] = parent[parent[next][j - 1]][j - 1];
                }

                depth[next] = depth[now] + 1; //// next의 depth는 현재의 depth++;
                q.add(next);

            }
        }
    }

 

LCA

 

    static int LCA(int a, int b) {
        // detph 맞추기
        // 0. 항상 a보다 b가 아래에 있는 상태로 만들어주기
        if (depth[a] > depth[b]) {
            int tmp = a;
            a = b;
            b = tmp;
        }

        //1. 양쪽 노드의 깊이를 맞춰주기 (B를 A가 있는 depth까지 끌어올리기)
        // 1 ---------->12 몇층 이동할까?
        // 12---->4-->2->1
        for (int i = MAX-1; i >= 0; i--) {
            if (depth[b] - depth[a] >= (1 << i)) { // 2^i : 이동할 수 있는만큼 이동하기
                b = parent[b][i];
            }
        }

        // 2. a,b 높이가 맞춰진 상태 - 현재 위치가 LCA인 경우?
        if (a == b) { return a; }
        //3. 양쪽을 동시에 2진법으로 끌어올릴수 있는 만큼 끌어올리는데,단 부모가 다르면 이동
        for (int i = MAX-1; i >= 0; i--) {
            if (parent[a][i] != parent[b][i]) { //부모가 다르면 이동
                a = parent[a][i];
                b = parent[b][i];
            }
        }

        return parent[a][0];
    }

N to N ( N<=500)

출발지와 도착지 모두 N개일때 쓰는 알고리즘

시간복잡도가 O(N^3)이므로 N이 적을때만 사용 가능하다.

 

i지점에서 j 지점까지 갈때의 최단거리가

k 지점을 거쳐서 가면 어느것이 더 최단거리일까? 라는것을 구해주면 된다.

 

 

샘플 코드

    
    static int[] d;
    static int N;
    static ArrayList<Node>[] adj = new ArrayList[N+1];
    static void floyd() {
        //1. d배열 INF 채우기
        Arrays.fill(d, INF);

        //2. 입력값으로 들어오는 간선 cost 받기 adj

        for (int k = 1; k <= N; k++) { //경유지가 밖에 있어야함.-> 대상이 되는 경유지를 고정 해야함.
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
                }
            }
        }
    }

두번째로 벨만포드를 정리해보고자 한다.

 

음수 가중치가 있을때 최단거리를 구하는 알고리즘이다.

 

V번 E개의 간선에 대해 dist 배열 갱신한다.
* V번째에 dist 배열의 갱신이 발생하면 -> 음의 사이클 존재

 

요 음의 사이클이 존재 하는지 안하는지가 벨만포드에서 가장 중요하다.

이유는? (V-1)번까지 돌았는데 V번째에서 dist 배열 갱신이 발생한다면?

사이클이 있는데 그값이 계속 감소한다는 것이다. 가중치가 음수가 있기 때문에 가능한 현상이다.

 

그래서 문제를 풀다보면 음의 사이클이 있는가? 를 묻는 문제도 더러 있다

 

 

 

 

샘플코드 

    static int[] dist;
    static int N;
    static ArrayList<Node>[] adj = new ArrayList[N+1];
    static int belman() {
        //1. dist 배열 INF 값으로 채우기, 출발지는 0으로
        Arrays.fill(dist, INF);
        dist[1] = 0;

        //2. V번 E개의 간선은 탐색 (음수 사이클 체크를 위해 V-1+1번 체크)
        boolean isUpdated;
        for (int i = 1; i <= N; i++) { // V
            isUpdated = false;
            for (int here = 1; i <= N; here++) {// E
                for (Node next : adj[here]) {//dist 배열 업데이트
                    int nextCost = dist[here] + next.cost;
                    if (dist[here] != INF && dist[next.idx] > nextCost) {
                        //dist[here] != INF : 연결이 안된다는 것을 확인 , 현재노드인 here가 이전에 방문했어야함 그래야 거쳐서 가니깐 
                        dist[next.idx] = nextCost;
                        isUpdated = true;
                    }
                }
                if (!isUpdated) break; // 더 이상 최단 경로 갱신이 안일어 나면 조기종료
            }
            if (isUpdated) return -1;
        }
        return dist[N];
    }

 

 

어떤 정점에서 출발해서 모든 노드들로 가기까지 최단거리들을 구하는 알고리즘

 

특징

1. 음의 가중치가 없다. 무조건 양의 가중치이다.

-> 가중치가 모두 같으면? BFS로푼다.

 

2. 이전에 풀었던 부분 최단거리가 최단거리임을 보장한다.

 

3. Priority Queue를 사용하여 가중치순으로 정렬한다.

Priority Queue<Node> pq = new Priority Queue <>( (o1,o2)->Long.compare(o1.cost,o2.cost);

pq를 사용하는 이유?

  • Cost순으로 정렬되기 위해, 거리가 적은 순으로 뽑아서 노드를 거쳐서 가면
  • 최소임이 보장되기 때문에 pq 사용한다.

 

4. 최단거리 배열은 MAX값으로 초기화 시켜준다 ( 최단거리를 구하기 위해)

 

5. 인접배열은 양방향, 단방향을 고려해준다.

 

 

응용

1. 왔다 갔다 최단거리 (출발 -> 도착 정점 -> 출발)

-  출발정점에서 최단거리 구하고 도착정점에서 최단거리 더해서 두개 더해

 

2. 단일 도착 지점에 대한 최단거리 (1~N-1 번 정점에서 출발 N번 도착)

- 반대로 N에서 출발해서 최단거리 구하기

 

3. 여러 지점에서 출발하는 최단거리

- 가상의 출발지점에서 가중치 0으로 출발 지점들을 연결한 후 최단거리 구하기

 

4. 최단거리의 경우의 수 구하기 ( 백준 14554 )

 - 배열하나를 더 선언해, 최단거리로 업데이트 하면, 다음 경로로 가는 경우의 수에 기존 경로의 수를 넣어주고,

   최단거리가 같으면? 해당 지점에 오는 경우의수가 늘어나는 것이므로, 

   다음 경로의 수에 기존경로+ 다음경로를 더해준다.

                        if (dist[newX][newY] > dist[now.x][now.y] + cost) { // 최단거리 업데이트
                            dist[newX][newY] = dist[now.x][now.y] + cost;
                            pq.add(new Node(newX, newY, dist[newX][newY], 0));
                            path[newX][newY] = path[now.x][now.y];
                        } else if (dist[newX][newY] == dist[now.x][now.y] + cost) { // 최단거리가 같으면
                            path[newX][newY] = path[now.x][now.y] + path[newX][newY]; // 경우의수 누적
                        }

 

샘플 코드

    static int[] dist;
    static int N;
    static PriorityQueue<Node> pq = new PriorityQueue<>((o1, o2) -> Long.compare(o1.cost,o2.cost));
    static ArrayList<Node>[] adj = new ArrayList[N+1]; // main에서 초기화 필요 
	static void dijkstra() {
        //0. 초기화 dist 배열 INF 값으로 채우기 , 시작점은 0, q에 시작점 add
        Arrays.fill(dist, INF);
        dist[1] = 0;
        pq.add(new Node2(1, 0));

        while (!pq.isEmpty()) {
            Node now = pq.poll();
            if (dist[now.idx] < now.cost) { // 현재 노드의 최소거리가 가져온 cost 보다 작다면 넘어가도됨
                continue; // 이미 최단거리를 확정했으면 돌필요가없음 아니면 시간초과
            }
            for (Node next : adj[now.idx]) {
                if (dist[next.idx] > dist[now.idx] + next.cost) { // 최단거리이면
                    dist[next.idx] = dist[now.idx] + next.cost; // 거리 업데이트 해주고
                    pq.add(new Node(next.idx, dist[next.idx]); // pq에 값 넣기 -> cost : 업데이트된 거리값
                }
            }
        }
    }

 

 

 

알고리즘 시험에 패스한 기념으로

그동안 알고리즘 공부한걸 정리해보고자 한다 ^^ (기쁜맘으로)

 

그렇담 우선 Graph 최단거리 3종 아이들부터 정리해보고자 한다.

 


최단거리 알고리즘은 3가지가 대표적이다.

 

1. 다익스트라

2. 벨만포드

3. 플로이드 워셜

 

1) 시작점 , 도착점

1 to 1 : 다익스트라

1 to N : 다익스트라

N to 1 : 다익스트라 (역방향 그래프를 만들어 도착점을 출발점으로 하는 1 to N 다읷트라 수행) - 역다익

N to N : 플로이드 워셜

 

2) 간선의 가중치

가중치가 없으면?   BFS

가중치가 있으면서 양수이면 ? 다익스트라 (=> Priority Queue 사용)

가중치가 있으면서, 음수이면? 벨만포드 

 

3) 트리 

-> LCA

 

 

이번에 vue.js 개발을 많이 하게되면서

가장 헷갈리게 된 포인트가 이것이다

 

언제 computed를 쓰고, 언제 watch를 쓰지?

사실 두개다 얻어지는 결과값은 엇비슷하기 때문이다

 

그래서 이 고민을 많이 했다

그러면 더 이상 고민하지 않도록 정리보도록 하쟈 ㅎㅎ

 

 

예제도 쓰면 좋지만 ㅎㅎ vue 공식문서에 있는것을 보면 될듯 싶다.


1. computed : 반응형 getter

- 사용하기 편하고, 자동으로 값을 변경하고 캐싱해주는 반응형 getter

- 선언형 프로그래밍 방식

- 계산된 결과가 캐싱된다. computed 속성은 해당 속성이 종속된 대상이 변경될때만 함수를 실행한다

  • 이는 method와 다른 점이다. method를 호추하면, 렌더링을 할 때마다, 항상 함수를 실행한다.

- computed는 computed에 새로운 프로퍼티를 추가해 주어야한다. data와 혼재에서 사용 불가

 

2. watch : 반응형 콜백

- 프로퍼티가 변경될 때, 지정한 콜백 함수가 실행 : 반응형 콜백

- data에 새로 프로퍼티를 추가 할 필요 없고, 명시된 프로퍼티를 감시할 것이다~를 표현해주면된다.

- vue 공식 문서에, computed와 watch 둘다 가능 한 것은 computed를 쓰라고 명시되어 있다.

  • 선언형 프로그래밍이 명령형 프로그래밍보다 코드 반복 및 우수해서

 

 

3. 언제쓸까?

1) data 에 할당 된 값들 사이의 종속관계를 자동으로 세팅 : computed

2) 프로퍼티 변경시점에 action이 필요할때 (api call , router ...) : watch

3) computed는 종속관계가 복잡할 수록 재계산시점을 알 수 없어서 종속관계의 값을 리턴하는것 이외에는 코드 지양

4) computed와 watch 둘다 가능 한 것은 computed

 

5) data의 실시간/빈번한 update가 필요한것은 watch,  한번 렌더링 되었을때만 update되면 되는것은 computed

 좀 애매할 수도 있지만 실제로 개발하면서 느꼈던 것이다.

여러 컴포넌트들 사이의 부모-자식관계가 있는데 이와중에 받은 props를 또 자식에서 변경하거나, 하는 요건이 많은데

페이지를 처음 렌더링 할때 1번만 해당 data를 update하면 된다면 compted를

계속해서 다른 컴포넌트 사이의 정보가 업데이트 되면서 해당 정보가 현재 달라졌는지? 실시간으로 보아야한다면 watch를 써 주었다.

 

6) computed는 이미 정의된 계산식에 따라 결과값을 반환할때,

  watch는 특정한 어똔조건에서 함수를 실행시키기 위한 트리거로 사용 가능

 

 

 

 

 


참고

kr.vuejs.org/v2/guide/computed.html

medium.com/@jeongwooahn/vue-js-watch%EC%99%80-computed-%EC%9D%98-%EC%B0%A8%EC%9D%B4%EC%99%80-%EC%82%AC%EC%9A%A9%EB%B2%95-e2edce37ec34

강화학습 교육 들은걸 정리하고자 한다,,

정리안하면 까먹으니까 ^^,,

기억나는데 까지 해보쟈...ㅁ7ㅁ8

 


1. 기계학습의 분류

지도학습 label 된 Data를 이용하여 학습
input data에 결과값이 있음.
정답을 신경망에 학습시킴
비지도학습 label이 없는 data를 이용하여 학습

강화학습 보상을 최대화 하는 Decision Making 학습
학습해서 나온 값을 가지고 모델링 
보상을 학습 시키기 위해 지도학습을 한다 -> 최종 보상값을 학습한다.
인공지능이 서택을 함
정답이 없는 상태 score만 보고 학습을 시킴

 

2. 지도학습

- 정답을 신경망에 학습 시킴

- Gradient Descent

  •  신경망을 만들고 LOSS를 정의한후, 사용하면 신경망이 수정됨 -> LOSS값이 낮아짐
  • 신경망 F ( input -> output)
  • LOSS : 신경망의 성능지표 
optimizer = torch.optim.Adam(F.parameters())

optimizer.zero_grad()
LOSS.backward() //미분 : 기울기를 구한다 
optimizer.step() // 적당히 작은 값을 곱해서 minimum cost에 가까워지게 한다 Back propagation

반복 적용하여 LOSS값을 낮춘다.

 

- 지도학습이 유용한 이유? 학습시키지 않은 값들도 output을 구할 수 있다. ( 추론 가능 )

 

3. 강화학습

score를 최대화 하는 output을 선택

에이전트가 현재의 상태를 인식하여 선택 가능한 행동들 중 보상을 최대화 하는 행동을 선택

 

- Challenge 1 : 학습을 위해 탐험 필요

  • Exploration (탐험) vs Exploitation (활용) 의 균형이 필요

- Challenge 2 : 장기적 보상 추구 

 

 

3.1 가치기반 강화 학습 ( Value Based )

- 모든 state에 대해서 기대 할 수 있는 최종 보상값을 계산하고, 그 값을 이용하여 action을 선택

- 탐험을 제외 하고, 각 state 마다 action 결정되어 있음

 

1) Monte-Carlo Method

- Episode를 한번 완전히 진행해야 한번 학습하는 것이다.

- History에서 배운다.

- 보상을 학습시키기 위해 지도학습을 한다 -> 최종 보상 값을 학습한다.

- 좋은 학습을 위해 가끔 활용( Exploitation) 대신 탐험(Exploration)이 필요

- Episode 진행 중간에 잘못된 action하나가 그전 action을 모두 나쁜 것으로 만듦

2) SARSA Method

- 한번의 state - action step 단위로 학습함

- Boot-strapping 통한 지도학습

- 한 에피소드당 N개의 loss 확보

- F(s1)[a1] : state1 에서 action1 했을 받을 있는 reward

- F(s1)[a1] = reward1+ F(s2)[a2] 되도록 학습을 시키기 위해서 둘의 차이 = loss

- 중간에 엉터리 답을 내지 않는 논리적인 network 만들 있게 해준다.

3) Q-Larning Method & More

- Sate-Action-Reward-State

- DQN 알고리즘 (유명함) :Replay Memory ? 경험들을 따로 메모리에 저장해두고 경험들을 random하게 뽑아서 연관성 없이 학습하는 것이 제대로 학습을 있다.

 

 

3.2 정책 기반 강화 학습 ( Policy Based )

- 언제나 확률적으로 action 선택

- 신경망의 output action 대한 확률로 정의

 

1) Gradient Ascent

- Gradient Descent의 반대

- LOSS대신 -SCORE , SCORE를 높이도록 학습

- SCORE : 강화학습을 위한 신경망의 성능 지표

              Agent가 정책에 따라 에피소드를 진행 했을 때 얻을 최종 보상의 기댓값

optimizer = torch.optim.Adam(F.parameters())

optimizer.zero_grad()
(-SCORE).backward() 
optimizer.step() 

 

2) Vanilla Policy Gradient

- 최종 보상 기대 값을 SCORE로 사용할 수 없는 이유 ? tree가 너무 큼, 

 환경이 일반적으로 확률성을 포함하고 있어서, 같은 state에서 같은 action을 했더라도 이후 state가 일정하지 않음

- 너무 많으니깐 sampling 된걸 쓰고싶어~ 그런데 , SCORE대신 J simpe을 쓰면 고르게 sampling 되지 않고 

확률이 높은 tragectory가 더 많이 sample됨 

  -> J sampling = logP(trag.) * R(traj.)을 사용하면 sampling을 사용하면서도 기존과 똑같이 Gradient Ascent 적용가능

3) Policy Gradient with Baseline

-평균이 60 나온 시험에서 50 받는것과, 평균이 30 나온 시험에서 50점받는 것중 평균 30점인게 더좋은것이기 때문에 +쪽으로 더많이 가도록 학습해야한다. 아니면 - 쪽으로 ( cartpole..)

- Baseline 기준점 역할인데 처음부터 너무 높으면 모델이 잇는 최대치보다 높으면 baseline 설정 의미가 없어지기 때문에 평균값을 하면 의미 있는 값이다.

 

정책기반에서는 모델이 항상 확률적으로 action 선택하는 선택한 결과의 점수가 reward이고,

평균으로 baseline 잡아주면 현재수준에서 잘하는지 못하는지 알기 쉽기 때문에 학습을 효율적으로 있게 해준다.

 

postgresql을 Centos7에 설치해보겠당

 

근데 서버가 yum이나 library를 인터넷에서 받아오는 환경이 아니어서

tar 파일을 postgresql에서 받아주었다.

 

https://www.postgresql.org/ftp/source/v12.0/

 

PostgreSQL: File Browser

 

www.postgresql.org

 

 

1. tar 압축해제

tar xvfz postgresql-12.0.tar.gz

 

 

2. configure 파일 설정

sudo ./configure --prefix=/apim/data/postgresql/pgsql --without-readline --without-zlib

 

왠만하면 다 sudo권한으로 넣어서 명령어 실행시켜주었다.

 

--prefix 는 설치 디렉토리를 지정해주는 경로이다.

 

그리고 나는 서버에서 readline이랑 zlib이 없어서 빼고 설치하라고 나와서 without을 설정해주었다.

뒤에 두개 옵션은 빼도된다.

 

 

3. postgresql 설치

sudo make
sudo make install

 

 

4. DB 설치

 ./initdb -D /data

/data 라는 경로에 DB를 설치해 주었다.

원하는 경로를 입력 하면 된다.

/data라는 경로에 한 이유는 DB 마운트를 저 경로로 했기 때문이다.

 

 

5. DB 기동

./pg_ctl  start -D /data ( status, restart , stop)

 

start 대신해서 status를 입력하면 현재 상태

restart는 재기동

stop은 기동중지를 할 수 있다 ~_~

 

 

6. 외부 접속 허용

/data/postgresql.conf 에서

    1. listen_addresses = ‘localhost’ –> listen_addresses = ‘*’ 수정

data/pg_hba.conf 에서

  • host all all 0.0.0.0/0 password 추가 

 

7. psql 접속

./psql

 

8. 접속 한뒤 database 생성 및 user 생성

postgres=# CREATE DATABASE {DBname};
postgres=# CREATE USER {UserName};
postgres=# ALTER USER {UserName}  WITH PASSWORD '{Password}';

 

 

 

스키마 생성 및 삭제

Create schema {schemaName};

Drop schema {schemaName} cascade;

 

스키마 이름 변경 

ALTER SCHEMA schema_name RENAME TO new_schema_name;

 

스키마 소유자 변경

ALTER SCHEMA username OWNER TO new_username;

 

 

 

해당 database내의 schema 확인

\dn

 

현재 디비 계정및 role 정보

\du  

 

데이터베이스 접속

\connect {databaseName}

 

데이터베이스 목록조회 

\list  
\l

 

데이터베이스 목록 상세조회

\list+  
\l+

참고

https://lahuman.jabsiri.co.kr/173

 

[CentOS 6]Postgresql 소스 설치

Postgresql 소스 설치 정리 계정 생성 $> adduser postgres postgres 계정으로 로그인 $> su - postgres postgresql 소스 다운로드와 압축 해제 $> wget https://ftp.postgresql.org/pub/source/v9.5.7/postgresql..

lahuman.jabsiri.co.kr

http://blog.naver.com/hanccii/221701395102

 

PostgreSQL db, schema, user 권한 관리

PostgreSQL에서는 database 를 생성하면 default schema로 public 이라는 schema가 생성이 되며,backen...

blog.naver.com

 

 

'DEVELOP > DB' 카테고리의 다른 글

[postgreSql] pg_dump 하는 방법  (0) 2021.03.15
[DB]Isolation Level 알아보기  (0) 2020.07.19
[mySql] 계정 생성 및 권한 설정  (0) 2020.05.25
[MariaDB] general log 설정하기  (0) 2020.05.25
DB (mysql) 설정 변경  (0) 2020.03.13

+ Recent posts