Week 5. 그래프 데이터베이스 (Neo4j)

// 노드 생성
CREATE (m:Movie {title: "Inception", year: 2010})
CREATE (d:Director {name: "Christopher Nolan"})
 
// 관계 생성
CREATE (d)-[:DIRECTED]->(m)
 
// 조회
MATCH (d:Director)-[:DIRECTED]->(m:Movie)
WHERE d.name = "Christopher Nolan"
RETURN m.title, m.year

from neo4j import GraphDatabase
 
class MovieGraph:
    def __init__(self, uri, user, password):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))
 
    def add_movie(self, title, year, director):
        with self.driver.session() as session:
            session.run("""
                MERGE (d:Director {name: $director})
                MERGE (m:Movie {title: $title, year: $year})
                MERGE (d)-[:DIRECTED]->(m)
            """, title=title, year=year, director=director)
 
    def find_movies_by_director(self, director):
        with self.driver.session() as session:
            result = session.run("""
                MATCH (d:Director {name: $director})-[:DIRECTED]->(m:Movie)
                RETURN m.title AS title, m.year AS year
            """, director=director)
            return [dict(record) for record in result]
 
# 사용
graph = MovieGraph("bolt://localhost:7687", "neo4j", "password")
graph.add_movie("Inception", 2010, "Christopher Nolan")
movies = graph.find_movies_by_director("Christopher Nolan")

// 2단계 관계 탐색
MATCH path = (a:Actor)-[:ACTED_IN]->(:Movie)<-[:ACTED_IN]-(coactor:Actor)
WHERE a.name = "Tom Hanks"
RETURN DISTINCT coactor.name
 
// 최단 경로
MATCH path = shortestPath(
    (a:Actor {name: "Kevin Bacon"})-[*]-(b:Actor {name: "Tom Hanks"})
)
RETURN length(path), [n IN nodes(path) | n.name]

// 감독별 영화 수
MATCH (d:Director)-[:DIRECTED]->(m:Movie)
RETURN d.name, count(m) AS movieCount
ORDER BY movieCount DESC
LIMIT 10

// 인덱스 생성
CREATE INDEX movie_title FOR (m:Movie) ON (m.title)
CREATE INDEX director_name FOR (d:Director) ON (d.name)
 
// 복합 인덱스
CREATE INDEX movie_year_title FOR (m:Movie) ON (m.year, m.title)
 
// 전문 검색 인덱스
CREATE FULLTEXT INDEX movie_search FOR (m:Movie) ON EACH [m.title, m.plot]

// 노드
(:Movie {title, releaseDate, rating, runtime})
(:Person {name, birthDate})
(:Genre {name})
 
// 관계
(:Person)-[:DIRECTED]->(:Movie)
(:Person)-[:ACTED_IN]->(:Movie)
(:Movie)-[:HAS_GENRE]->(:Genre)

// 인셉션과 같은 장르 + 같은 배우 영화 추천
MATCH (m:Movie {title: "Inception"})-[:HAS_GENRE]->(g:Genre),
      (m)<-[:ACTED_IN]-(a:Person)-[:ACTED_IN]->(rec:Movie)
WHERE rec <> m AND (rec)-[:HAS_GENRE]->(g)
RETURN rec.title, count(*) as score
ORDER BY score DESC LIMIT 5