iridescent

starting Tomcat v9.0 Server at localhost

더블 클릭

tomcat admin port가 -가 되어있는 것을 알 수 있다. 

8005번으로 바꾸면 됨

• HTML5
• CSS3
• JavaScript
• jQuery : javascript 를 간단하게 하기 위해
• HTML5 API
  • 하이퍼 링크 이미지
  • 하이퍼 링크 텍스트 
• AJAX

• 웹표준에 기반한 웹사이트 개발은 필수!
• 디자인 : css
• HTML5
  • head 요소
  • body 요소
• 바디 끝에 javascript코드를 삽입하는게 좋음
  • html을 읽는 과정에 스크립트 만나면 중단 시점이 생기고 그 만큼 display에 표시되는게 지연됨
  • dom 트리가 생성되기전에 자바스크립트가 생성되지 않은 dom의 조작을 시도할 수 있다. 
  • https://velog.io/@takeknowledge/script-%ED%83%9C%EA%B7%B8%EB%8A%94-%EC%96%B4%EB%94%94%EC%97%90-%EC%9C%84%EC%B9%98%ED%95%B4%EC%95%BC-%ED%95%A0%EA%B9%8C%EC%9A%94

http://html5test.com/index.html

- 지금 사용하고 있는 브라우저 지원 점수

• css
  • 렌더링 
• javacript
  • 동적으로 변화시킬 목적으로 사용함 
    • 태그 내용을 변경할 수 있도록 접근 할 수 있어야 한다. 
    • 태그를 하나 하나 객체로 만들어서 접근 = DOM
  • 비교 연산자 : === (엄격한 등가연산)
    • 타입을 맞춰놓고 비교한다.
  • 배열
    • 자바보단 자바스크립트가 더 좋나봐?
  • 함수
    • 함수 이름 없이 만들땐 변수에 담아서 사용
    • 멤버 변수만 각각 할당하고, 메소드는 공유함 : 프로토 타입
    • 메소드 많을 땐, 객체 리터럴 방식 X
    • 데이터만 가지고 있을 때, 객체 리터럴 방식 사용함
  • DOM 객체
    • html태그들을 접근 할 때 사용함 
• AJAX
  • XML
    • 비동기 통신할 때 주고 받는 통신 
    • 목적에 따라 태그명 정할 수 있음
  • 재로드하지 않고 웹페이지의 일부부만 갱신

https://www.w3schools.com/

db.datecoll.insert ( {_id : 1, name :'가나다', dt : ISODate()})
db.datecoll.insert ( { _id:2, name: 'abc', dt:ISODate("2020-01-01") } )
db.datecoll.insert ( { _id:3, name: 'xyz', dt:ISODate("2021-05-25 13:10") } )
db.datecoll.insert ( { _id:4, name: 'lmn', dt:ISODate("2021-05-25T13:05") } )
db.datecoll.insert ( { _id:5, name: 'ㅋㅋ', dt:ISODate("2020-10-05") } )
db.datecoll.insert ( { _id:6, name: 'mmm', dt: new Date() } )
db.datecoll.insert ( { _id:7, name: 'kkk', dt:ISODate("1998-11-07T00:00:00Z") } )

• 공백을 넣어줘도 되고 T도 넣어줘도됨
• 시분초 설정 안 하면 0시 0분 0초가 된다. 

db.datecoll.find().sort({dt:1})		//	dt에 대해서 내림차순 정렬
db.datecoll.find().sort({dt:-1})	//	dt에 대해서 오름차순 정렬

년도만 출력하기

1. cursor 변수 사용

var v = db.datecoll.find()
while(v.hasNext()){
	var d = v.next();
	print(d.dt.getYear()+1900)
}

• getYear() : 세기만 나온다. 꼭 1900더해줘야한다. 

2. forEach 사용

db.datecoll.find().forEach( 
	function(c){
    	print(c.dt.getFullYear()); 
    } 
)

2021
2020
2021
2021
2020
2021
1998

• 이름없는 변수를 만들어서 전달,
• 수행만 하겠다 하면 forEach써라/

3. map사용

db.datecoll.find().map(
	function(c){
		c = c.dt.getFullYear();
		return c;
	}
)

[ 2021, 2020, 2021, 2021, 2020, 2021, 1998 ]

• 처리하고 결과 리턴
• 리턴 된 것을 차곡 차곡 보관했다가 리스트에 담아서 return 
• 반복문 없어도 됨. 

package mongo.level1;

import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;
import com.mongodb.MongoClient;

public class MongoJava {
	public static void main(String[] args) {
		try {
			MongoClient mongoClient = new MongoClient(new MongoClientURI("mongodb://localhost:27017"));
			System.out.println("접속 성공-------");
			MongoIterable<String>dblist = mongoClient.listDatabaseNames();
			System.out.println("[데이터 베이스 리스트]");
			for(String name : dblist)
				System.out.println(name);
			MongoDatabase db = mongoClient.getDatabase("edudb");
			MongoIterable<String> clist = db.listCollectionNames();
			System.out.println("[edudb 데이터베이스의 컬렉션 리스트]");
			for(String name : clist) {
				System.out.println(name);
			}
			mongoClient.close();
		}catch (Exception exception) {
			System.err.println(exception.getClass().getName() + " : " + exception.getMessage());
		}
	}
}

package mongo.level1;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;

public class SelectMongo1 {
	public static void main(String[] args) {
		try {
			MongoClient mongoClient = new MongoClient("localhost", 27017);
			MongoDatabase db = mongoClient.getDatabase("edudb");
			MongoCollection<Document> collection = db.getCollection("book");
			MongoCursor<Document> cursor = collection.find().iterator();
			while(cursor.hasNext()) {
				System.out.println(cursor.next());
			}			
		}catch (Exception exception) {
			System.err.println(exception.getClass().getName() + " : " + exception.getMessage());
		}
	}
}

• 모두다 json형식이지만, mongoDB에 들어가는 데이터만 도큐먼트 

[읽어오기]

package mongo.level1;

import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
public class SelectMongo2 {
	public static void main(String[] args) {
		Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
		mongoLogger.setLevel(Level.SEVERE);
		try {
            MongoClient mongoClient = new MongoClient("localhost", 27017);
            MongoDatabase db = mongoClient.getDatabase("edudb");
            MongoCollection<Document> collection = db.getCollection("book");
            MongoCursor<Document>  cursor = collection.find().iterator();
            while(cursor.hasNext()) {
            	System.out.println(cursor.next());           
            }  		          
            System.out.println("--------------------------------");
            cursor = collection.find().iterator();
            while(cursor.hasNext()) {
            	Document doc = cursor.next();
            	System.out.println(doc.get("name") + " : " + doc.get("price"));           
            }      
            System.out.println("--------------------------------");
            Consumer<Document> printConsumer1 = new Consumer<Document>() {
                @Override
                public void accept(final Document document) {
                    System.out.println(document.toJson());
                }
            };            
           collection.find().forEach(printConsumer1);
           System.out.println("--------------------------------");
           Consumer<Document> printConsumer2 = doc -> System.out.println(doc.toJson());                    
           collection.find().forEach(printConsumer2);
            mongoClient.close();
        } catch (Exception exception) {
            System.err.println(exception.getClass().getName() + ": " + exception.getMessage());
        }
	}
}

• Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
  • org.mongodb.driver패키지에 들어가있는 출력을 다 무시해라 
• mongoLogger.setLevel(Level.SEVERE);
  • elvel.SEVERE레벨만 출력해라 
• new MongoClient("localhost", 27017);
  • 서버주소, 포트번호 각각 url형식말고, 각각 아규먼트로 주는 거 가능
• cursor = collection.find().iterator();
  • cursor객체는 한번만 읽을 수 있기 때문에, 한번 더 넣는다. 
• getint(), getString 가능
• System.out.println(doc.get("price").getClass().getName());
  • get객체가 어떻게 리턴하는지 알 수 있다. 
• doc.get("price")는 리턴객체가 double이지만, 오브젝트 형으로 가서 
  • 실제 object타입이라서 object형이 쓸 수 있는것만 사용할 수 있는데
  • 이게 정수형으로 바꿀려면
  • ((java.lang.Double)doc.get("price")).intValue())
•  Consumer<Document> printConsumer2 = doc -> System.out.println(doc.toJson());   
  • 람다 함수 식
    • 받아서 출력한다. 
  • 간단한 것만 가능 

package mongo.level1;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;

public class SelectMongo3 {

	public static void main(String[] args) {
		Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
		mongoLogger.setLevel(Level.SEVERE);
		try {
            MongoClient mongoClient = new MongoClient("localhost", 27017);
            MongoDatabase db = mongoClient.getDatabase("edudb");
            MongoCollection<Document> collection = db.getCollection("book");
           Document  doc = collection.find().first();
           System.out.println(doc.toJson());           
           
           FindIterable<Document>dlist = collection.find(Filters.gt("price", 10000));
           for(Document doc1 : dlist)
           		System.out.println(doc1.toJson());
           
          dlist = collection.find(Filters.eq("name", "javascript"));
           for(var doc1 : dlist)
           		System.out.println(doc1.toJson());
           
           dlist = collection.find(Filters.regex("name", "^ja"));
           for(var doc1 : dlist)
           		System.out.println(doc1.toJson());
           
          dlist =  collection.find(Filters.and(Filters.gt("price", 10000), Filters.lte("price", 20000)));
          for(Document doc1 : dlist)
         		System.out.println(doc1.toJson());
 
            mongoClient.close();
        } catch (Exception exception) {
            System.err.println(exception.getClass().getName() + ": " + exception.getMessage());
        }
	}
}

• collection.find().first();
  • 첫번째 도큐먼트만
• filters이용
  • gt, eq, regex, lte메소드 사용

package mongo.level1;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
public class SelectMongo4 {

	public static void main(String[] args) {
		Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
		mongoLogger.setLevel(Level.SEVERE);
		try {
			MongoClient mongoClient = new MongoClient("localhost", 27017);
			MongoDatabase db = mongoClient.getDatabase("edudb");
			MongoCollection<Document> collection = db.getCollection("datecoll");
			Document doc = collection.find().first();
			System.out.println(doc.toJson());

			FindIterable<Document> dlist = collection.find(Filters.eq("name", "ㅋㅋ"));
			for (var doc1 : dlist) {
				Document doc2 = doc1;
				System.out.println(doc2.get("dt"));
				Date d = (Date)doc2.get("dt");
				SimpleDateFormat sdf = new SimpleDateFormat ( "yyyy년 MM 월 dd일 HH시 mm분 ss초"); 
				System.out.println(sdf.format(d)); 
			}
			mongoClient.close();
		} catch (Exception exception) {
			System.err.println(exception.getClass().getName() + ": " + exception.getMessage());
		}
	}
}

• MongoCollection<Document> collection = db.getCollection("datecoll");
  • datecoll에서 컬렉션 가지고 오기
• 자바스크립트 데이터 객체를 불러오기
• Date d = (Date)doc2.get("dt");
  • iso데이터 객체, js데이터 객체는 java.util.Date객체로 변환해서 온다. 
    • dt : Mon Oct 05 09:00:00 KST 2020
  • Data형으로 강제 형 변환

package mongo.level1;

import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Projections;

public class SelectMongoLab {
	public static void main(String[] args) {
		Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
		mongoLogger.setLevel(Level.SEVERE);
		try {
            MongoClient mongoClient = new MongoClient("localhost", 27017);
            MongoDatabase db = mongoClient.getDatabase("edudb");
            MongoCollection<Document> collection = db.getCollection("cuty");
            Bson obj = Projections.fields(Projections.include("name","age","book"));
            MongoCursor<Document>  cursor = collection.find().projection(obj).iterator();
        	
            while(cursor.hasNext()) {
            	Document doc = cursor.next();
            	//getDouble(get("name")) 	//가능
            	System.out.printf("%s 팀원의 나이는 %.0f\n",doc.get("name"), doc.get("age"));
            	System.out.println("[좋아하는 책리스트]");
            	List<Document> data = new ArrayList<Document>();

            	ArrayList<Document> bookList = (ArrayList<Document>) doc.get("book" );
            	for(Document b : bookList) {
            		System.out.println("책이름 : " + b.get("bookname"));
            		System.out.println("출판사 : " + b.get("publishing_house"));
            		if(b.get("Genre")!= null)System.out.println("장르 : " + b.get("Genre"));
            	}
            	System.out.println("-------------------------------------------------------------");
            }  
            mongoClient.close();
		}catch (Exception e) {
			// TODO: handle exception
		}
	}
}

• Bson obj = Projections.fields(Projections.include("name","age","book"));
• MongoCursor<Document>  cursor = collection.find().projection(obj).iterator();
  • 모든거 출력해도 되는데 원하는 것만 출력한다. 
  • find하는데 두번째 아규먼트라고 생각하면 됨.

package mongo.level1;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Updates;

public class UpdateMongo1 {
	public static void main(String[] args) {

		Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
		mongoLogger.setLevel(Level.SEVERE); 
		try {
            MongoClient mongoClient = new MongoClient();
            MongoDatabase db = mongoClient.getDatabase("edudb");
            MongoCollection<Document> collection = db.getCollection("book");
            
            collection.updateOne(Filters.eq("name", "spring"), Updates.set("price", 29999));
            collection.updateOne(Filters.eq("name", "spark"), Updates.inc("price", 11));
            MongoCursor<Document>  cursor  = collection.find().iterator();
            while(cursor.hasNext()) {
            	Document doc1 = cursor.next();
            	System.out.println(doc1.get("name") + " : " + doc1.get("price"));           
            }      
            mongoClient.close();
        } catch (Exception exception) {
            System.err.println(exception.getClass().getName() + ": " + exception.getMessage());
        }
	}
}

• 원하는 필드만 updateone

package mongo.level1;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;

public class UpdateMongo2 {

	public static void main(String[] args) {
		Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
		mongoLogger.setLevel(Level.SEVERE);
		try {
            MongoClient mongoClient = new MongoClient();
            MongoDatabase db = mongoClient.getDatabase("edudb");
            MongoCollection<Document> collection = db.getCollection("book");
            Bson filter = Filters.eq("name", "spring");
            Document doc = new Document("name", "SPRING").append("price", 30000);
            collection.replaceOne(filter, doc);
       
            MongoCursor<Document>  cursor  = collection.find().iterator();
            while(cursor.hasNext()) {
            	Document doc1 = cursor.next();
            	System.out.println(doc1.get("name") + " : " + doc1.get("price"));           
            }      
            mongoClient.close();
        } catch (Exception exception) {
            System.err.println(exception.getClass().getName() + ": " + exception.getMessage());
        }
	}
}

• Filters.eq("name", "spring");
  • 이름이 spring인거 찾아서 bson 객체로

• 서브 파티 api
  • import com,
  • import org

mongoDB는 오토인크리먼트가 없음

명령어

• 필드명
  • 단일 인용부호, 더블, 안쓰든 상관 없다 (mongoDB만)
• 외부 파일로 내보내기
  
  • mongoexport --db 데이터베이스명 -c 컬렉션명 --out 파일패스
• josn 문서를 도큐먼트로 데리고 오기
  • mongoimport --db 데이터베이스명 -c 컬렉션명 --file 제이슨명.josn
• find
  1. 조건 (생략하면 안됨 - 객체의 형식은 갖춰야 한다.)
     • 없으면 null을 주거나 비어두면 됨. 
  2. 꺼내고자 하는 데이터

배열 데이터에 대한 쿼리

db.book.find({price : {$lt:10000}},{name : true, price : true, _id: false}}

1. 연산자를 필드로 넣은 것
   • sql에서 where절 
   • 10000보다 작은 값
2. 추출하고자하는 필드의 대한 정보
   • {name : true, price : true, _id: false}
   • sql에서 select절

db.book.find({$and : [{price:{$get : 10000}},{price : {$lt : 20000}}]},{name : true, price : true, _id: false}}

• 값 여러개 쓰고 싶을 땐, array
• $and : 논리 곱 (두개의 비교식이 모두 만족하면)
  • 두개의 식이니깐 리스트로 주고 있다.

void print(int p1, String p2)

• 자바 스크립트는 매개변수 하나만 전달해도 들어감
• 3개 넣으면 앞에서 부터 2개 전달함 (한개 버림)
• p2한테만 전달 불가, p1한테 null이라도 줘야함 

db.book.find({price : {$gt:8000}}).count()

• db 커리 객체에 count호출 

db.book.find({name : {"$regex":"^java"}})

db.book.find({name : /^java/})

• 정규표현식 객체로 인식한다 -> /붙이면
  • $regex 생략
  • 자바스크립트 특성

db.inventory.insertMany([
	{item:"journal", qty : 25, tags:["blank","red"], dim_cm:[14,21]},
	{item:"notebook", qty : 50, tags:["red","blank"], dim_cm:[14,21]},
	{item:"journal", qty : 25, tags:["red", "blank", "plain"], dim_cm:[14,21]},
	{item:"planner", qty : 75, tags:["blank","red"], dim_cm:[22.85, 30]},
	{item:"postcard", qty : 45, tags:["blue"], dim_cm:[10,15.25]}
]);

• insertMany : 한번에 다 넣기

db.inventroy.find({tags:["red", "blank"]})

• tags값이 red, blank 배열값만 가지는 친구만 
• 순서도 지키고, 두개의 값만 들어가있는 것만

db.inventroy.find({tags:{$all:["red","blank"]}})

• red, blank을 가지고 있는 얘들 모두 

db.inventroy.find({tags: "red"})

• 레드가 들어가 있는 얘들은 다 꺼내라 

db.inventroy.find({dim_cm: {$gt:25}})

• 조건을 만족하는 얘를 꺼내라 

db.inventroy.find({dim_cm: {$elemMatch:{$gt:22, $lt:30}}})

• elemMatch : 주어진 비교식 중에서 하나라도 만족하는 얘를 꺼내겠다. 
• 22보다 크고 30보다 작은 값이 하나라도 있으면

db.inventroy.find({dim_cm.1: {$gt:25}})

• dim_cm.1 : dim_cm이란 필드의 두번째 값

db.inventroy.find({"tags": {$size:3}})

• tags의 사이즈가 3인 값 (3개의 값을 가진 것)

db.inventroy.find({"dim_cm.0": {$eq:14}})

• dim_cm필드의 첫번째 값이 14와 같은 거 꺼내라

value값이 임베디드 객체에 대한 쿼리

• 포함되는 객체 = 임베딩 객체 
• "."을 이용해서 멤버 접근 

db.inventory1.insertMany([
	{item:"journal", qty : 25, size : {h:14, w:21, uom:"cm"}, status:"A"},
	{item:"notebook", qty : 50, size : {h:8.5, w:11, uom:"in"}, status:"A"},
	{item:"paper", qty : 100, size : {h:8.5, w:11, uom:"in"}, status:"D"},
	{item:"planner", qty : 75, size : {h:22.85, w:30, uom:"cm"}, status:"D"},
	{item:"postcard", qty : 45, size : {h:10, w:15.25, uom:"cm"}, status:"A"},
]);

db.inventory1.find()

db.inventory1.find({size : {h:14, w:21, uom:"cm"}}, {_id:false})

• 이 조건을 정확하게 만족하는 애를 찾아라 
• _id : false -> id 제외한 모두 출력

db.inventory1.find({size : {w:21, h:14, uom:"cm"}}, {_id:false})

• 객체 구성 그대로 줘야함

db.inventory1.find({"size.uom" : "in"}, {_id:false})

• uom만 가지고 비교하고 싶다. 

db.inventory1.find({"size.h" : {$lt : 15}}, {_id:false})

db.inventory1.find({"size.h" : {$lt : 15}, "size.uom" : "in", status : "D"}, {_id:false})

• 여러가지 조건을 하나의 json 조건에 넣을 수 있다.

임베디드 객체를 원소로 갖는 배열에 대한 쿼리

• 원소들이 객체들인 배열 : 객체 배열

db.inventory2.insertMany([
	{item:"journal", instock : [{warehouse:"A", qty : 5}, {warehouse:"C", qty:15}]},
	{item:"notebook", instock : [{warehouse:"C", qty : 5}]},
	{item:"paper", instock : [{warehouse:"A", qty : 60}, {warehouse:"B", qty:15}]},
	{item:"planner", instock : [{warehouse:"A", qty : 40}, {warehouse:"B", qty:5}]},
	{item:"postcard", instock : [{warehouse:"B", qty : 15}, {warehouse:"C", qty:35}]},
]);

db.inventory2.find({"instock":{warehouse:"A", qty:5}})

db.inventory2.find({"instock":{qty:5, warehouse:"A"}})

db.inventory2.find({"instock.qty":{$lte:20}})

db.inventory2.find({"instock.0.qty":{$lte:20}})

db.inventory2.find({"instock":{$elemMatch:{qty:5, warehouse:"A"}}})

• qty가 5이고, warehouse가 "A"인 것

db.inventory2.find({"instock":{$elemMatch:{qty:{$gt:10, $lte:20}}}})

• qty가 10보다 크고, 20보다 작거나 같은 것 모두
• 원소(객체)단위로 찾음

db.inventory2.find({"instock.qty":{$gt :10, $lte:20}})

• 10보다 크거 or 20보다 작거나 같은거 모두

db.inventory2.find({"instock.qty":5,"instock.warehouse":"A"})

• qty가 5이거나, A인것 모두

• 데이터 저장할 때 최소 단위는 도큐먼트
  • 도큐먼트는 한 덩어리의 json객체이다. 
• 필드 값 
  
  • 싱글값, 객체, 배열, 객체배열
• 값이 객체 : 임베딩 객체

cursor객체

• find한 결과를 변수에 담을 때
• js : var사용해서 객체 생성
• find가 리턴하는 것 : cursor객체 
• cursor객체는 내용 한번만 읽을 수 있음
• 10분동안 사용하지 않으면 만료됨

var myCursor = db.book.find().limit(3)
while(myCursor.hasNext()){
	doc = myCursor.next();
	print("-------------------------------------------");
	printjson(doc)
}

var myCursor = db.book.find().skip(2).limit(2)
myCursor.forEach(print)

var myCursor = db.book.find().skip(2).limit(2)
myCursor.forEach(printjson)

var myCursor = db.book.find({}, {name:true, price : true, _id:false})
printjson(myCursor[0])

var myArray = myCursor.toArray()
myArray

• myCursor는 한번만 쓸 수 있기때문에 toArray하면 myCursor 내용없어짐
• toArry( ) : 각각의 데이터 스캔함 

정규표현식

 db.book.copyTo("book2")	//book컬렉션 book2로 복사
 
 db.book.find({"name":/^java/})		//	java로 시작하는
 
 db.book.find({"name":/java/})		//	java포함 = %java%
 
 db.book.find({"name":/java$/})		//	java로 끝나는것	= %java
 
 db.book.find({"name":/j|a|v/})		//	j or a or v를 포함하는 
 db.book.find({"name":/[jav]/})		//	j or a or v를 포함하는
 
 db.book.find({"name":/[a-k]/})		//	a,b,c,d,e,f,g,h,i,j,k 중에 하나를 포함하는
 
 db.inventory.find({item:{$not : /^p.*/}});	//	p로 시작하고 임의의 문자가 뒤에 0개 이상오는게 아닌것
 db.inventory.find({item : {$not:{$regex:"^p.*"}}})
 db.inventory.find({item : {$not:{$regex:/^p.*/}}})

• nosql : mongoDB
  • RDB 와 nosql차이는?
  • 어떤 점이 좋은가?
  • monogoDB가 RDB를 대신할 수 있는건 아님
  • api 준비해야함 : 내장 X
  • driver준비할때 api도 같이 사용할 수 있음
  • 5개 부족하면 다시 붙일 수 있음
• RDB
  • 테이블 늘릴려면 컴퓨터 성능을 높여야 함

mongoDB

• 도큐먼트 데이터베이스
  • 도큐먼트 : mongoDB가 데이터를 저장하는 최소 단위
    • 필드와 쌍으로 구성됨
    • 관계를 갖는 중첩 도큐먼트와 배열을 사용하여 1개의 도큐먼트로 표현 가능
  • 데이터 입출력
    • JSON형식의 도큐먼트 사용
  • 데이터 저장
    • 이진 포맷으로 인코딩한 BSON 형식의 도큐먼트로 변환되어 저장됨
• 테이블을 만들지 않음
• 콜랙션이라는 것을 만듦

  	mongoDB	RDB
  스키마	- 컬럼 얼마든지 원하는대로 만들 수 있음 - key, value쌍으로 저장 - 테이블 구조 없음 - 문서 작성 규칙  - 같은 필드라도 데이터 타입이 다를 수 있음 (비정형 스키마)	- 이미 만들어져 있는 컬럼에 대해서만 가능 - 갑자기 컬럼 추가 못함 (정형데이터) - 똑같은 컬럼 구조여야함 - 데이터 구조 미리 정함
  SQL	NOSQL	SQL
  	- 저장되어 있는 형식을 지정하지 않는다.  - free	- 중복 최소화시 여러개의 테이블 나눠서 저장 - 테이블간에 관계 있음
  서버 확장	- 서버 확장 시 붙이면 됨	- 서버 확장 시 전체 복사해야함
  트랜젝션	- 트랜젝션 불가능 - 성능을 더 크게 생각함	- 트랜젝션 가능 (은행업무) - 다른 유저들은 commit할 때까지 볼 수 없음 - jdbc는 자동 커밋
  JOIN	- Join 지원 X - 임베디드 방식 or 레퍼런스 방식의 도큐먼트 구조 사용하고 나서 애플리케이션에 조인해야함	- join 지원 O
  	컬렉션 사용	테이블 사용
  	도큐먼트	행

• 유연성
  • 도큐먼트를 바꾼다고 해서 특별히 할 일은 없다. 
• 확장성
  • 서버 확장 가능
  • 백업 안 해도 됨
  • 가져다 붙이면 됨
• 고성능
  • 대용량 처리 성능 뛰어남
  • 일관성
  • 트랜젝션 포기
• 가용성
  • 데이터 저장할 때, 4개의 머신 묶어놓은 것을 클러스터라고 함
  • 마스터가 데이터 저장할 때, 슬레이브가 여러곳에 복제해서 저장
  • 단일 컴퓨터 환경 X
  • 장애가 생기더라도 쓰는 데이터는 읽고 쓰는 거 지장 X
• 스케일링에 좋다
  • 성능을 키우는데 적합하다.
  • 스케일 아웃 
    
    • 그냥 붙이는 것, 
    • 환경설정 해줘야함
• 데이터 저장시 BSON형식으로 저장해서 사용함

데이터 조작어 ( DML )

insert

// mongoDB
db.member.insert({no : "C001", age : 45, status : "A"})

//관계형 DB
insert into memeber(no, age, status) values('C001', 45, 'A')

1. db : 현재 사용준인 db 참조하는 내장 변수
   • 내장 변수 : 선언하지 않아도 사용 가능
2. member : 컬렉션 이름 
3. insert : 하고자 하는 작업
4. 한 덩어리의 JSON형식 컨텐츠가 하나의 도큐먼트가 된다. 
   • 몇개가 될 수 있는지 제한 없다. 
   • 키 : 필드
   • no필드, age 필드, status 필드
   • 필드 명에 더블인용부호 안 줘도 된다. 
     • 근데 진짜 JSON은 줘야함

update (수정)

// mongoDB
db.member.update({age : {$gt : 25}}, {$set : {status : "C"}}, {multi : true})

• {multi : true} → 다중, 모두 다
• {multi : false} → 최초 하나만 바꿈
• {$gt : 25} 네임 벨류
  • $gt : 연산자 (크다 연산자)
  • key에는 일반 문자형만 올 수 있어서

1. 아규먼트 찾은거
2. 어떻게 업데이트 할 것인가
3. 추가적으로 전달하는 부가정보 (옵션)

//관계형 DB
updete memeber set status = 'C' where age > 25

삭제

// mongoDB
db.member.remove({no : "C001"})

• 필드명이 C001인 것을 삭제해라

//관계형 DB
delect from member where no = 'C001'

조건에 해당하는 JSON 객체 안 주면 ALL이 된다. 

스키마

실습

use 데이터 베이스 이름

- 없으면 새로 만들어줌 

db

- 현재 사용하고 있는 db 뭐냐

show dbs

- 도큐먼트 한개도 없으면 온전한 db가 될 수가 없다.

db.book.insert({"name":"python","price":10000})

• book 컬렉션 먼저 만들어주고
• 그 안에 도큐먼트 넣어줌

show collections

현재 안에 있는 컬렉션들을 보여달라

db.book.find()

// 가격이 낮은 순
db.book.find().sort({"price":1})  


// 가격이 높은 순
db.book.find().sort({"price":-1})


// 가격이 높은 순 - 여러개 설정
db.book.find().sort({"price":-1,"name":1})

// 이름이 자바스크립트인 서적만 꺼내라
db.book.find({"name":"javascript"})

// 자바로 시작하는 친구 
db.book.find({"name" : {"$regex":"^java"}})

//가격이 8000넘는 친구 
db.book.find({"price" : {"$gt":8000}})

//가격이 8000보다 작거나 같은
db.book.find({"price" : {"$lte":8000}})

• 데이터 일치
  
  • 연산자 : regex
  • ^ : 시작하는 문자
    • ^java : 자바로 시작하는
  • $ : 끝나는 문자
  • . : 개행식을 제외한 모든 문자
• 연산
  • lt : 미만
  • lte : 이하
  • gt : 초과
  • gte : 이상

//메서드 전부 다 나옴
db.book.help()

//	첫번째 아규먼트 아무것도 없는 것 -> 안 주면 안됨
//	name필드는 꺼내, price는 빠짐 (name만 꺼내고, id는 언급 안 하면 무조건 나옴)
db.book.find({},{'name':1})

//	id는 안 뽑고 싶다 (따로 언급 안 한건 모두 0이 됨) 
db.book.find({},{'name':1,'_id':0})


//	꺼내고 싶은 것 true로 
db.book.find({},{'name':true})

• 아무것도 설정 안 해주면 0임
• 1이나 true와 같음

db.book.find({price : {$lt : 10000}},{name : true, price : true, _id : false})

• 첫 번째 아규먼트는 where절과 비슷
• 두번째는 select와 비슷

db.book.find({}, {'name':0, _id:0})

• 언급한 필드가 다 false이면 다 true라고 인식함
• 위의 코드 name, _id빼고 price나옴 

1. java 6부터 url보고 자동으로 알아서 찾아줌
2. VO클래스 (DTO,,,)
   • 값을 보관하는 객체
   • 다룰려는 데이터를 하나로 묶어서 다룰 때 사용하는 객체 - valueobject
   • 맴버 변수 선언
   • 직접적으로 접근 못하게 private로 막아놈
   • get/setter 

package mysql.level2;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class VisitorCRUD {
	public boolean c(Scanner scan) {
		boolean result = false;
		Connection conn = MySQL.connect();
		try (PreparedStatement pstmt = conn
				.prepareStatement("insert into visitor (name, writedate, memo) values (?, now(), ?)")) {
			while (true) {
				System.out.print("작성자 이름을 입력하세요 : ");
				String name = scan.nextLine();
				System.out.print("글의 내용을 입력하세요 : ");
				String memo = scan.nextLine();
				;
				pstmt.setString(1, name);
				pstmt.setString(2, memo);
				pstmt.executeUpdate();
				System.out.println("visitor 테이블에 데이터 삽입 완료");
				System.out.print("계속 입력하겠습니까?(y/n) ");
				String aws = scan.nextLine();
				if (aws.equalsIgnoreCase("y")) {
					continue;
				}
				break;
			}
			result = true;
		} catch (SQLException se) {
			System.out.println(se.getMessage());
		}
		MySQL.close(conn);
		return result;
	}

	public List<VisitorVO> r() {
		Connection conn = MySQL.connect();
		List<VisitorVO> vlist = null;
		try (Statement stmt = conn.createStatement()) {
			ResultSet rs = stmt.executeQuery(
					"select id, name, date_format(writedate, '%Y년 %m월 %d일') writedate, memo from visitor order by writedate desc");
			vlist = new ArrayList<VisitorVO>();
			while (rs.next()) {
				VisitorVO vo = new VisitorVO();
				vo.setId(rs.getInt("id"));
				vo.setName(rs.getString("name"));
				vo.setWriteDate(rs.getString("writedate"));
				vo.setMemo(rs.getString("memo"));
				vlist.add(vo);
			}
		} catch (SQLException se) {
			System.out.println(se.getMessage());
		}
		MySQL.close(conn);
		return vlist;
	}

	public boolean u(Scanner scan, int id) {
		boolean result = false;
		Connection conn = MySQL.connect();
		try (PreparedStatement pstmt = conn.prepareStatement("update visitor set name = ?,  memo = ? where id = ?")) {
			System.out.print("수정할 작성자 이름을 입력하세요 : ");
			String name = scan.nextLine();
			System.out.print("수정할 글의 내용을 입력하세요 : ");
			String memo = scan.nextLine();
			pstmt.setString(1, name);
			pstmt.setString(2, memo);
			pstmt.setInt(3, id);
			pstmt.executeUpdate();		
			result = true;
		} catch (SQLException se) {
			System.out.println(se.getMessage());
		}
		MySQL.close(conn);
		return result;
	}

	public boolean d(int id) {
		boolean result = false;
		Connection conn = MySQL.connect();
		try (PreparedStatement pstmt = conn.prepareStatement("delete from visitor where id = ?")) {
			pstmt.setInt(1, id);
			pstmt.executeUpdate();
			result = true;
		} catch (SQLException se) {
			System.out.println(se.getMessage());
		}
		MySQL.close(conn);
		return result;
	}
}

• c - create
• r - read
• u - update
• d - delet

visitorDAO : 

• db전담하는 클래스 
• database access object