notebooks/graphdb-insights.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add, Modify and Retrieve data from OrientDB\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Install the PyOrient package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install pyorient --user "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** <font color=blue>Now restart the kernel by choosing Kernel > Restart. </font> **"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Import packages and libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyorient, json, pandas as pd\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Add your service credentials for Object Storage\n",
    "* You must create Object Storage service on Bluemix. To access data in a file in Object Storage, you need the Object Storage authentication credentials. Insert the Object Storage authentication credentials as <i><b>credentials_1</b></i> in the following cell after removing the current contents in the cell. Rename the variable to <i><b>credentials_1</b></i> if the variable name is different. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# @hidden_cell\n",
    "# The following code contains the credentials for a file in your IBM Cloud Object Storage.\n",
    "# You might want to remove those credentials before you share your notebook.\n",
    "credentials_1 = {\n",
    "    'IBM_API_KEY_ID': '',\n",
    "    'IAM_SERVICE_ID': '',\n",
    "    'ENDPOINT': '',\n",
    "    'IBM_AUTH_ENDPOINT': '',\n",
    "    'BUCKET': '',\n",
    "    'FILE': ''\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Loading the Configuration and Data Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Load the config.json from Object Storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from botocore.client import Config\n",
    "import ibm_boto3\n",
    "\n",
    "cos = ibm_boto3.client('s3',\n",
    "                    ibm_api_key_id=credentials_1['IBM_API_KEY_ID'],\n",
    "                    ibm_service_instance_id=credentials_1['IAM_SERVICE_ID'],\n",
    "                    ibm_auth_endpoint=credentials_1['IBM_AUTH_ENDPOINT'],\n",
    "                    config=Config(signature_version='oauth'),\n",
    "                    endpoint_url=credentials_1['ENDPOINT'])\n",
    "\n",
    "\n",
    "'''Retrieve file from Cloud Object Storage'''\n",
    "fileobject = cos.get_object(Bucket=credentials_1['BUCKET'], Key=credentials_1['FILE'])['Body']\n",
    "   \n",
    "\n",
    "'''Load the file contents into a Python string'''\n",
    "\n",
    "\n",
    "text = fileobject.read()\n",
    "\n",
    "# Decode UTF-8 bytes to Unicode, and convert single quotes \n",
    "# to double quotes to make it valid JSON\n",
    "text_json = text.decode('utf8').replace(\"'\", '\"')\n",
    "# print(text_json)\n",
    "# print('- ' * 20)\n",
    "\n",
    "# Load the JSON to a Python list & dump it back out as formatted JSON\n",
    "data = json.loads(text_json)\n",
    "node_data = json.dumps(data, indent=4, sort_keys=True)\n",
    "print(node_data)\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Load the IMDb movie data from Object Storage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert the csv file as `Insert as pandas dataframe` and change the name of the dataframe df_data to imdb_df in the cell below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' There are many rows and columns in the data that are empty. Hence, It is important to clean the data.\n",
    "All the empty rows and columns are dropped from the dataframe using dropna() function of pandas.'''\n",
    "\n",
    "imdb_df = imdb_df.dropna()\n",
    "imdb_df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  5. Connect to OrientDB\n",
    "* Uncomment the first line after entering the IP address of the Kubernetes cluster and the port. Make sure to put the IP address in the double quotes and replace the content in the angular brackets with node-port to avoid any syntax errors.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#client = pyorient.OrientDB(\"ip-address-of-the-kubernetes-cluster\",<node-port mapped to port 2424 of orientDB>)\n",
    "print(client)\n",
    "\n",
    "# The session id username and password is global password that was set for orientDB\n",
    "session_id = client.connect(node_data['username'], node_data['password'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Utility functions\n",
    "These methods return dataframes containing the existing information of the database based on a condition.\n",
    "* check_if_class_present_or_not.\n",
    "* check_if_person_already_present.\n",
    "* check_if_already_present_movie.\n",
    "* find_the_Cluster_id_of_a_class\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_if_class_present_or_not(classname):\n",
    "    '''This function checks if a class is present or not'''\n",
    "    \n",
    "    name=\"will be replaced by query result name\"\n",
    "    query = \"SELECT FROM ( SELECT expand( classes ) FROM metadata:schema ) WHERE name = \" +'\"'+ classname + '\"'\n",
    "    a = client.command(query)\n",
    "    \n",
    "    for k in a:\n",
    "        name = k.name\n",
    "    \n",
    "    if(name == classname):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "     \n",
    "def check_if_person_already_present():\n",
    "    '''This function checks if the person already exists.'''\n",
    "    \n",
    "    check_if_already_present = \"select * from person\"\n",
    "    c = client.command(check_if_already_present)\n",
    "    d=[]\n",
    "\n",
    "    for name in c:\n",
    "        d.append([name.name, name.role, name.fblikes])\n",
    "\n",
    "\n",
    "    check_df = pd.DataFrame(list(d), columns=['name','role','fblikes'])\n",
    "    return check_df\n",
    "\n",
    "\n",
    "def check_if_already_present_movie():\n",
    "    '''This function checks if the movie already exists.'''\n",
    "    \n",
    "    check_if_already_present = \"select title , year from movie\"\n",
    "    c = client.command(check_if_already_present)\n",
    "  \n",
    "    d=[]\n",
    "\n",
    "    for name in c:\n",
    "        d.append([name.title, name.year])\n",
    "\n",
    "\n",
    "    check_df_movie = pd.DataFrame(list(d), columns=['title','year'])\n",
    "    return check_df_movie\n",
    "\n",
    "\n",
    "def find_the_Cluster_id_of_a_class(classname):\n",
    "    '''This function finds the Cluster ID of the class.'''\n",
    "    \n",
    "    find_the_Cluster_id_of_a_class = \"SELECT defaultClusterId from (SELECT expand( classes ) FROM metadata:schema) where name = '\" + classname + \"'\"\n",
    "    c = client.command(find_the_Cluster_id_of_a_class)\n",
    "    for ids in c:\n",
    "        return ids.defaultClusterId\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Core Functions\n",
    "These are the core functions of the notebook performing operations on OrientDB:\n",
    "* Create Database.\n",
    "* Create node class with its properties as per defined in config.json.\n",
    "* Create node class when no schema defined.\n",
    "* Create edge class.\n",
    "* Create vertices/nodes with movie data.\n",
    "* Create relations between these nodes.\n",
    "* Create vertices for usecases where schema is indefinte.\n",
    "* Other insights like :\n",
    "    * Most mentioned movie.\n",
    "    * Movies with rating above 7.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createDatabase(node_data):\n",
    "    '''This function the database if it does not already exist.'''\n",
    "    \n",
    "    if client.db_exists( node_data['Database_name'], pyorient.STORAGE_TYPE_MEMORY ):\n",
    "        client.db_open(node_data['Database_name'],node_data['username'], node_data['password'])\n",
    "        print \"The Database \" + node_data['Database_name'] + \" \"+ \"has already been created and opened for use.\"\n",
    "    else:        \n",
    "        client.db_create( node_data['Database_name'], pyorient.DB_TYPE_GRAPH, pyorient.STORAGE_TYPE_MEMORY )\n",
    "        print \"The Database \" + node_data['Database_name'] + \" created and opened successfully\"\n",
    "        \n",
    "\n",
    "def createNodeClass_withSchema(node_data):\n",
    "    '''This function creates a Node Class with a schema.'''\n",
    "    \n",
    "    for class_name,value in node_data['vertex_class'].items():\n",
    "        bool_result = check_if_class_present_or_not(class_name)\n",
    "        if(not bool_result):\n",
    "            command_to_create_node = \"create class\"+\" \"+ class_name +\" \"+ \"extends V\"\n",
    "            cluster_id = client.command(command_to_create_node) \n",
    "            for property_name,value in node_data['vertex_class'][class_name].items():\n",
    "                command_to_create_property= \"create property\"+ \" \"+ class_name +\".\" + property_name +\" \" +\"IF NOT EXISTS \" + value\n",
    "                client.command(command_to_create_property) \n",
    "            print \"The class \" + class_name + \" and its properties have been created successfully.\"\n",
    "        else:\n",
    "            print \"The class \" + class_name + \" has been created already.\"\n",
    "\n",
    "def createNodeClass_NoSchema(node_data):\n",
    "    '''This function creates a Node Class with no schema.'''\n",
    "    \n",
    "    for class_name,value in node_data['vertex_class'].items():\n",
    "        if(check_if_class_present_or_not(class_name)):\n",
    "            command_to_create_node = \"create class\"+\" \"+ class_name +\" \"+ \"extends V\"\n",
    "            cluster_id = client.command(command_to_create_node) \n",
    "            print \"The class \" + class_name + \" has been created with cluster id \" +cluster_id\n",
    "        else:\n",
    "            print \"The class \" + class_name + \" has been created already.\"\n",
    "            \n",
    "\n",
    "def createEdgeClass(node_data):\n",
    "    '''This function checks if the edge class is already present.'''\n",
    "    \n",
    "    for class_name,v in node_data['edge_class'].items():       \n",
    "        if(not check_if_class_present_or_not(class_name)):\n",
    "            command_to_create_edge_class = \"create class\"+\" \"+ class_name +\" \"+ \"extends E\"\n",
    "            cluster_id = client.command(command_to_create_edge_class)\n",
    "            print(\"The Edge class\" +\" \" + class_name + \" has been created successfully.\")\n",
    "\n",
    "            for key,val in node_data['edge_class'][class_name].items():\n",
    "                command_to_create_property= \"create property\"+ \" \"+ class_name +\".\" + key +\" \" +\"IF NOT EXISTS \" + node_data['edge_class'][class_name][key]['Type']+\" \" + node_data['edge_class'][class_name][key]['Linked_Class']\n",
    "                client.command(command_to_create_property)                 \n",
    "        else:\n",
    "             print(\"The Edge class\" +\" \" + class_name + \" already exists.\")\n",
    "            \n",
    "\n",
    "def creating_records(imdb_df):\n",
    "    '''Create records in the database if it does not exist.'''\n",
    "    \n",
    "    for index, row in imdb_df.iterrows():\n",
    "        check_df = check_if_person_already_present()\n",
    "        if(any(check_df.name == row[\"actor_1_name\"])):\n",
    "            print \"Node \"+row[\"actor_1_name\"] +\" is already present.\"\n",
    "        else:\n",
    "            command_to_create_actor_1_node_class_person  = \"INSERT INTO person (name, fblikes, role) VALUES (\" +'\"' +row[\"actor_1_name\"]+'\"' + ','+ str(row[\"actor_1_facebook_likes\"])+',' +'\"' +'actor'+'\"' + \")\"\n",
    "            client.command(command_to_create_actor_1_node_class_person)\n",
    "            \n",
    "        if(any(check_df.name == row[\"actor_2_name\"])):\n",
    "            print \"Node \"+row[\"actor_2_name\"] +\" is already present.\"\n",
    "        else:\n",
    "            command_to_create_actor_2_node_class_person  = \"INSERT INTO person (name, fblikes, role) VALUES (\" +'\"' +row[\"actor_2_name\"]+'\"' + ','+ str(row[\"actor_2_facebook_likes\"])+',' +'\"' +'actor'+'\"' + \")\"\n",
    "            client.command(command_to_create_actor_2_node_class_person)\n",
    "            \n",
    "        if(any(check_df.name == row[\"actor_3_name\"])):\n",
    "            print \"Node \"+row[\"actor_3_name\"] +\" is already present.\"\n",
    "        else:\n",
    "            command_to_create_actor_3_node_class_person  = \"INSERT INTO person (name, fblikes, role) VALUES (\" +'\"' +row[\"actor_3_name\"]+'\"' + ','+ str(row[\"actor_3_facebook_likes\"])+',' +'\"' +'actor'+'\"' + \")\"\n",
    "            client.command(command_to_create_actor_3_node_class_person)\n",
    "            \n",
    "        if(any(check_df.name == row[\"director_name\"])):\n",
    "            print \"Node \"+row[\"director_name\"] +\" is already present.\"\n",
    "        else:\n",
    "            command_to_create_director_node_class_person  = \"INSERT INTO person (name, fblikes, role) VALUES (\" +'\"' +row[\"director_name\"]+'\"' + ','+ str(row[\"director_facebook_likes\"])+',' +'\"' +'director'+'\"' + \")\"\n",
    "            client.command(command_to_create_director_node_class_person)\n",
    "            \n",
    "        command_to_create_movie  = \"INSERT INTO movie (title, year, durationInMins, imdbRating, genre, plotKeywords, numCriticForReviews, movieFacebookLikes) VALUES (\" +'\"' +row[\"movie_title\"]+'\"' + ','+ str(row[\"title_year\"])+','+str(row[\"duration\"])+','+str(row[\"imdb_score\"])+',' +'\"'+row[\"genres\"]+'\"' +','+'\"' +row[\"plot_keywords\"]+'\"'+','+str(row[\"num_critic_for_reviews\"])+','+str(row[\"movie_facebook_likes\"])+\")\"\n",
    "        client.command(command_to_create_movie)\n",
    "        \n",
    "        \n",
    "\n",
    "        \n",
    "def createRelationships():\n",
    "    '''This function creates relationships.'''  \n",
    "    \n",
    "    check_df = check_if_person_already_present()\n",
    "    check_df_movie = check_if_already_present_movie()\n",
    "    \n",
    "    for index, row in imdb_df.iterrows():\n",
    "        # Create an edge between actors_1 and actor_2.\n",
    "        if((row[\"actor_1_name\"]  in check_df.name.values) and (row[\"actor_2_name\"]  in check_df.name.values)):\n",
    "            command_to_create_edge_between_two_actors_1_and_2 = \"create edge worked_with from (select from person where name = \"+'\"'+row[\"actor_1_name\"]+'\"'+ \")\"+\" \" +\"to (select from person where name = \"+'\"'+row[\"actor_2_name\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_two_actors_1_and_2)            \n",
    "        else:\n",
    "               print \"Edge cant be created because vertex is not present.\", row[\"actor_1_name\"], \",\",row[\"actor_2_name\"]  \n",
    "\n",
    "\n",
    "        # Create an edge between actors_2 and actor_3.\n",
    "        if((row[\"actor_2_name\"]  in check_df.name.values) and  (row[\"actor_3_name\"]  in check_df.name.values) ):\n",
    "            command_to_create_edge_between_two_actors_2_and_3 = \"create edge worked_with from (select from person where name = \"+'\"'+row[\"actor_2_name\"]+'\"'+ \")\"+\" \" +\"to (select from person where name = \"+'\"'+row[\"actor_3_name\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_two_actors_2_and_3)            \n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_2_name\"], \",\",row[\"actor_3_name\"]\n",
    "\n",
    "\n",
    "        # Create an edge between actors_3 and actor_1.\n",
    "        if((row[\"actor_3_name\"]  in check_df.name.values) and ( row[\"actor_1_name\"]  in check_df.name.values )):\n",
    "            command_to_create_edge_between_two_actors_3_and_1 = \"create edge worked_with from (select from person where name = \"+'\"'+row[\"actor_3_name\"]+'\"'+ \")\"+\" \" +\"to (select from person where name = \"+'\"'+row[\"actor_1_name\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_two_actors_3_and_1)            \n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_2_name\"], \",\",row[\"actor_3_name\"]\n",
    "\n",
    "        # Create an edge between actors_1 and director.\n",
    "        if((row[\"actor_1_name\"]  in check_df.name.values) and  (row[\"director_name\"] in check_df.name.values) ):\n",
    "            command_to_create_edge_between_actor_1_and_director = \"create edge worked_with from (select from person where name = \"+'\"'+row[\"director_name\"]+'\"'+ \")\"+\" \" +\"to (select from person where name = \"+'\"'+row[\"actor_1_name\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_actor_1_and_director)\n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_1_name\"], \",\",row[\"director_name\"]\n",
    "\n",
    "        # Create an edge between actors_2 and director.\n",
    "        if((row[\"actor_2_name\"]  in check_df.name.values) and ( row[\"director_name\"] in check_df.name.values) ):\n",
    "            command_to_create_edge_between_actor_2_and_director = \"create edge worked_with from (select from person where name = \"+'\"'+row[\"director_name\"]+'\"'+ \")\"+\" \" +\"to (select from person where name = \"+'\"'+row[\"actor_2_name\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_actor_2_and_director)\n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_2_name\"], \",\",row[\"director_name\"]\n",
    "\n",
    "        # Create an edge between actors_3 and director.\n",
    "        if((row[\"actor_3_name\"]  in check_df.name.values) and ( row[\"director_name\"] in check_df.name.values) ):\n",
    "            command_to_create_edge_between_actor_3_director = \"create edge worked_with from (select from person where name = \"+'\"'+row[\"director_name\"]+'\"'+ \")\"+\" \" +\"to (select from person where name = \"+'\"'+row[\"actor_3_name\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_actor_3_director)\n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_3_name\"], \",\",row[\"director_name\"]\n",
    "\n",
    "        # Create an edge between actors_1 and movie.\n",
    "        if((row[\"actor_1_name\"]  in check_df.name.values) and  (row[\"movie_title\"] in check_df_movie.title.values)):\n",
    "            command_to_create_edge_between_actors_1_and_movie = \"create edge acted_in from (select from person where name = \"+'\"'+row[\"actor_1_name\"]+'\"'+ \")\"+\" \" +\"to (select from movie where title = \"+'\"'+row[\"movie_title\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_actors_1_and_movie)\n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_1_name\"], \",\",row[\"movie_title\"]\n",
    "\n",
    "        # Create an edge between actors_2 and movie.\n",
    "        if((row[\"actor_2_name\"]  in check_df.name.values) and  (row[\"movie_title\"] in check_df_movie.title.values) ):\n",
    "            command_to_create_edge_between_actors_2_and_movie = \"create edge acted_in from (select from person where name = \"+'\"'+row[\"actor_2_name\"]+'\"'+ \")\"+\" \" +\"to (select from movie where title = \"+'\"'+row[\"movie_title\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_actors_2_and_movie)\n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_2_name\"], \",\",row[\"movie_title\"]\n",
    "\n",
    "        # Create an edge between actors_3 and movie.\n",
    "        if((row[\"actor_3_name\"]  in check_df.name.values) and  (row[\"movie_title\"] in check_df_movie.title.values)):\n",
    "            command_to_create_edge_between_actors_3_and_movie = \"create edge acted_in from (select from person where name = \"+'\"'+row[\"actor_3_name\"]+'\"'+ \")\"+\" \" +\"to (select from movie where title= \"+'\"'+row[\"movie_title\"]+'\"'+\")\"\n",
    "            client.command(command_to_create_edge_between_actors_3_and_movie)\n",
    "        else:\n",
    "               print \"Edge cant be created because one or both the vertices is not present -\",row[\"actor_3_name\"], \",\",row[\"movie_title\"]\n",
    "\n",
    "        \n",
    "\n",
    "def creating_records_noschema(data):\n",
    "    '''This function creates records with no schema.'''\n",
    "    \n",
    "    id = client.record_create(cluster_id, data)\n",
    "    print \"Record succesfully created with \" + str(id)\n",
    "        \n",
    "\n",
    "\n",
    "def most_mentioned_movie():\n",
    "    '''This function retrieves the most mentioned movies.'''\n",
    "    \n",
    "    a = client.command(('select max(movieFacebookLikes) from movie '))\n",
    "\n",
    "    for max_num in a :\n",
    "        max_num = max_num.max\n",
    "    \n",
    "    most_mentioned_movie_object = client.command('select title from movie where movieFacebookLikes = ' + str(max_num))\n",
    "    \n",
    "    return most_mentioned_movie_object    \n",
    "        \n",
    "\n",
    "def movie_with_imdb_rating_above_7():\n",
    "    '''This function retrieves the movies with IMDb rating > 7.'''\n",
    "    \n",
    "    title = []\n",
    "    a = client.command(('select title from movie where imdbRating > 7 '))\n",
    "    for titles in a :\n",
    "        title.append(titles.title)\n",
    "    title_df = pd.DataFrame(list(title), columns=['title'])    \n",
    "    return title_df\n",
    "        \n",
    "\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Perform operations on OrientDB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.1 Create Database, Node classes, Edge classes, and Records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Database\n",
    "print \"\"\n",
    "print \"Creating database...\"\n",
    "createDatabase(node_data)\n",
    "print \"Database creation successful.\"\n",
    "\n",
    "# Create Node class with schema\n",
    "print \"\"\n",
    "print \"Creating Node classes with schema...\"\n",
    "createNodeClass_withSchema(node_data)\n",
    "print \"Node classes with schema creation successful.\"\n",
    "\n",
    "# Create Edge class\n",
    "print \"\"\n",
    "print \"Creating Edge classes...\"\n",
    "createEdgeClass(node_data)\n",
    "print \"Edge classes creation successful.\"\n",
    "\n",
    "# Create records\n",
    "print \"\"\n",
    "print \"Creating records...\"\n",
    "creating_records(imdb_df)\n",
    "print \"Records creation successful.\"\n",
    "\n",
    "# Create Relationships\n",
    "print \"\"\n",
    "print \"Creating relationships...\"\n",
    "createRelationships()\n",
    "print \"Relationships creation successful.\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.2 Create the records for the scenario where there is no schema defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "        'person': {\n",
    "                \"name\": \"John\", \n",
    "                \"role\": \"director\",\n",
    "                \"fblikes\": 400000.0,\n",
    "                \"born_in\" : 1980\n",
    "                },\n",
    "        }\n",
    "# Get cluster id\n",
    "for key, value in data.iteritems():\n",
    "        cluster_id = find_the_Cluster_id_of_a_class(key)\n",
    "        print \"Cluster Id:\",cluster_id\n",
    "\n",
    "# Create record that has no schema\n",
    "creating_records_noschema(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.3 Insights from OrientDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "most_mentioned_movie = most_mentioned_movie()\n",
    "print \"Most mentioned movies\"\n",
    "for titles in most_mentioned_movie:\n",
    "    print titles.title\n",
    "print \"\"    \n",
    "\n",
    "movie_with_imdb_rating_above_7 = movie_with_imdb_rating_above_7()\n",
    "print \"Movies with IMDb rating > 7:\"\n",
    "print movie_with_imdb_rating_above_7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Visualisation of results\n",
    "You can open OrientDB studio and execute the queries in the graph editor of OrientDB to view the graph you have built.\n",
    "Watch this video : https://www.youtube.com/watch?v=l-OVSjf-vk0&t=4s for OrientDB tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.5",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}