relatorio_final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NOSQL - Trabalho prátrico\n",
    "\n",
    "Autores: Amindo Machado (pg52170), Duarte Velho (pg53481), Mariana Oliveira (pg52648), Ricardo Oliveira (pg53501) e Rodrigo Esperança (pg50923)\n",
    "\n",
    "<p align=\"justify\">\n",
    "Este trabalho foi desenvolvido no âmbito da UC Bases de Dados NoSQL (2023/24), do Mestrado em Bioinformática da Escola de Engenharia da Universidade do Minho, e tem como objetivo explorar diferentes paradigmas de base de dados, tendo como referências dois tipos de modelos, um modelo relacional e um modelo não relacional. \n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"justify\">\n",
    "As bases de dados SQL são utilizadas para organizar e gerenciar grandes volumes de dados, utilizando a linguagem SQL para interagir com os dados, permitindo consultas, manipulações e análises complexas. Embora estas bases de dados possuam várias vantagens tais como padronização, maturidade, escalabilidade, flexibilidade e segurança também apresentam algumas desvantagens e problemas que podem levar a que não seja o tipo de base de dados ideal para algumas aplicações devido: à sua complexidade, à necessidade de manutenção regular e a elevados custos de implementação juntamente com\n",
    " as limitações em termos de escabilidade horizontal. Tendo em conta os problemas enfrentados aquando da utilização de bases de dados SQL e devido às demandas das aplicações modernas que lidam com dados não estruturados ou semiestruturados, surgiu uma nova categoria denominada de bases de dados **NoSQL** (Not Only SQL). Estas novas bases de dados não se baseiam no modelo relacional tradicional utilizado nas bases de dados SQL, onde a rigidez e a complexidade do modelo relacional podem ser um obstaculo à sua utilização em aplicações modernas.\n",
    "</p>\n",
    "\n",
    "De entre as várias características associadas às bases de dados NOSQL destacam-se a seguintes:\n",
    "\n",
    "- **Flexibilidade do esquema**: Permite o armazenamento dos dados sem necessidade de um esquema predefinido, adptando-se às necessidades da aplicação;\n",
    "\n",
    "- **Escabilidade Horizontal**: Possibilita a distribuição de dados em vários servidores, facilitando o aumento da capacidade conforme o crescimento da demanda. Além disso, a distribuição dos dados em vários servidores garante a disponibilidade do sistema mesmo em caso de falhas;\n",
    "\n",
    "- **Alto desempenho**: Estas bases de dados estão otimizadas para grandes volumes de dados e consultas complexas;\n",
    "\n",
    "- **Diversos modelos**: Suportam diversos modelos de dados;\n",
    "\n",
    "- **Agilidade de desenvolvimento**: Possibilitam um desenvolvimento mais rápido e ágil de aplicações devido à flexibilidade dos modelos de dados;\n",
    "\n",
    "- **Escabilidade superior**: Suportam o crescimento exponencial dos dados sem existir comprometimento do desempenho;\n",
    "\n",
    "- **Baixo custo** : Geralmente possuem custos de infraestrutura e licenciamento mais baixo do que as bases de dados SQL.\n",
    "\n",
    "\n",
    "Embora as bases de dados NOSQL tenham surgido para culmatar alguns dos problemas inerentes à utilização de bases SQL existem ainda alguns desafios face à sua utilização que podem difultar a sua implementação em alguns cenários:\n",
    "\n",
    "- **Falta de padronização**: A ausência de um padrão universal pode dificultar a interoperabilildade entre diferentes bases de dados NOSQL;\n",
    "\n",
    "- **Consistência dos dados**: A consistência dos dados distribuídos em vários servidores é um desafio;\n",
    "\n",
    "- **Maturidade relativa**: Como estas bases de dados ainda se encontram em desenvolvimento, existe menor disponibilidade de soluções maduras em comparação com as bases de dados SQL;\n",
    "\n",
    "- **Curva de aprendizagem**: Necessidade de conhecimento específico para modelar, gerenciar e consultar dados.\n",
    "\n",
    "\n",
    "Esta nova categoria de bases de dados é utilizada a nível das redes sociais, comércio eletrónico, aplicações móveis e análise de big data.\n",
    "\n",
    "\n",
    "Tal como referido anteriormente, uma das características específicas deste tipo de base de dados e que lhe confere várias vantagens é a grande diversidade de modelos disponívies existindo, atualmente quatro grandes modelos:\n",
    "\n",
    "- **Chave-Valor**: Este modelo armazena os dados em pares chave-valor, sendo caracterizados por serem simples e eficientes para consultas rápidas por chave, sendo por isso o modelo ideal para catálogos de produtos e sistemas de votação por exemplo (Redis);\n",
    "\n",
    "- **Documental**: Estes modelos organizam os dados em documentos JSON, que são caracterizados como flexíveis e perfeitos para o armazenamento de informações semi-estruturadas tal como perfis de usários ou registros de atividade (MongoDB);\n",
    "\n",
    "- **Grafos**: Neste tipo de modelos os dados são representados como entidades interligadas por relacionamentos sendo ideias para redes sociais ou análises de fraudes (Neo4j);\n",
    "\n",
    "- **Coluna**: Armazenamento dos dados em colunas sendo um modelo que é otimizado para a análise de grandes volumes de dados com alta performance.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Librarias e packages necessários\n",
    "\n",
    "Nesta secção são destacados todos os packages utilizados no trabalho, que facilitam a aquisição e análise de dados ao longo do documento, tornando mais eficiente a obtenção e compreensão das informações relevantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import oracledb\n",
    "import getpass\n",
    "import cx_Oracle\n",
    "import pymongo\n",
    "from pymongo import MongoClient\n",
    "import mysql.connector\n",
    "from py2neo import Graph, Node, Relationship\n",
    "from neo4j import GraphDatabase\n",
    "from datetime import datetime, timedelta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introdução\n",
    "\n",
    "O modelo relacional, organiza dados em tabelas bidimensionais chamadas \"relações\", onde cada linha é um registro e cada coluna é um atributo. Cada tabela tem um nome único, e as principais características incluem: chaves primárias, chaves estrangeiras e atributos. Este modelo é amplamento utilizado devido as regras de normalização utilizadas para a criação do modelo relacional na qual se verificar uma redução da redundância e aumento da organização dos dados. Além disso, é um modelo que garante a consistência e integridade dos dados através da utilização de chaves primárias e estrangeiras que são essências para a manutenção da integridade da base de dados. No entanto, este modelo apresenta diminuição da eficiência de consultas complexas para grandes volumes de dados e escabilidade limitada necissitandi de ajustes para suportar grande escalas de dados\n",
    "\n",
    "O Oracle é um dos principais sistemas utilizados para a gestão de bases de dados relacionais que implementa e estende o modelo relacional com várias funcionalidades avançadas, integrando a linguagem SQL, linguagem utilizada para definição, manipulação e consulta dos dados, juntamente com a linguagem PL/SQL utilizada para a criação de procedimentos, triggers e funções.\n",
    "\n",
    "A base de dados relacional utilizada como base deste trabalho prático representa um ambiente hospitalar e é constituída por 17 tabela ou entidade:\n",
    "\n",
    "- Hospital Patient: Contém informações sobre pacientes, incluindo ID, nome, tipo sanguíneo, email, gênero, data de nascimento, entre outros. Relacionado a histórico médico, seguros, episódios, contatos de emergência.\n",
    "\n",
    "- Hospital Medical History: Registra históricos médicos dos pacientes com detalhes como ID do registro, condição, data, etc. Referencia pacientes por meio de chaves estrangeiras.\n",
    "\n",
    "- Hospital Insurance: Gerencia informações sobre seguros, incluindo número da apólice, provedor, cobertura, etc. Conectado a pacientes por meio do número da apólice.\n",
    "\n",
    "- Hospital Emergency Contact: Contém detalhes dos contatos de emergência dos pacientes, incluindo nome, telefone e relação. Relacionado aos pacientes via chave estrangeira.\n",
    "\n",
    "- Hospital Episode: Registra episódios de tratamento dos pacientes, incluindo ID, data de admissão e alta. Conectado a pacientes e internações.\n",
    "\n",
    "- Hospital Appointment: Detalha agendamentos de consultas, incluindo data, hora, tipo de consulta, e IDs de médicos e episódios. Relacionado a episódios e médicos.\n",
    "\n",
    "- Hospital Bill: Gerencia informações de faturas hospitalares, incluindo ID, custos de sala, testes, total, status da conta, etc. Relacionado a episódios e pacientes.\n",
    "\n",
    "- Hospital Lab Screening: Registra exames de laboratório, incluindo ID do exame, tipo de teste, data e técnico responsável. Conectado a episódios e técnicos.\n",
    "\n",
    "- Hospital Staff: Contém informações sobre funcionários, incluindo ID, nome, data de entrada e saída, email, endereço, status, etc. Relacionado a departamentos.\n",
    "\n",
    "- Hospital Department: Gerencia informações dos departamentos hospitalares, incluindo ID, nome, chefe do departamento e número de funcionários. Relacionado a funcionários.\n",
    "\n",
    "- Hospital Doctor: Registra detalhes dos médicos, incluindo ID e qualificações. Conectado a funcionários.\n",
    "\n",
    "- Hospital Nurse: Contém informações sobre enfermeiros, incluindo ID e número do funcionário. Relacionado a funcionários.\n",
    "\n",
    "- Hospital Technician: Gerencia informações dos técnicos, incluindo ID e qualificações. Relacionado a funcionários e exames laboratoriais.\n",
    "\n",
    "- Hospital Room: Detalha as salas do hospital, incluindo ID da sala, tipo e número da sala. Relacionado a internações.\n",
    "\n",
    "- Hospital Hospitalization: Registra detalhes das internações, incluindo data de admissão e alta, sala e enfermeiro responsável. Relacionado a episódios, salas e enfermeiros.\n",
    "\n",
    "- Hospital Medicine: Contém informações sobre medicamentos, incluindo ID, nome, quantidade e custo. Relacionado a prescrições.\n",
    "\n",
    "- Hospital Prescription: Detalha prescrições médicas, incluindo ID, data, dosagem e ID do medicamento. Relacionado a episódios e medicamentos.\n",
    "\n",
    "\n",
    "![Modelo lógico da base de dados hospital](hospitalER.png)\n",
    "<figcaption>Figura 1- Modelo lógico da base de dados hospital</figcaption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objetivo\n",
    "\n",
    "<p align=\"justify\">\n",
    "O objetivo principal deste trabalho passou por explorar diferentes paradigmas de base de dados, tendo como referências dois tipos de modelos, um modelo relacional e um modelo não relacional. Em particular, o modelo não relacional será o mais explorado, sendo que, com auxílio de código (maioritariamente em python) procedeu-se, através de uma estratégia definida e explicada posteriormente, à \"conversão\" do modelo relacional, já dado em modelos não relacionais, explorando as bases de dados MongoDB e Neo4j e seus respetivos paradigmas. \n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # MongoDB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"justify\">\n",
    "O MongoDB é uma das bases de dados NoSQL orientada a documentos não relacional, para armazenamento de dados em documentos do tipo JSON possibilitando uma estrutura de dados flexível e de facil integração. De entre as várias bases de dados NoSQL o MongoDB destaca-se por ser uma das escolhas mais comuns para o armazenamento de dados não estruturados sendo uma escolha popular para o armazenamento de dados não estruturados devido à facilidade com se consegue realizar escalamento horizontal, ao seu elevado desempenho e linguagem de consulta rica que permite a recuperação e manipulação complexa dos dados, sendo que, além disso, é uma base de dados que se integra perfeitamente com plataformas em nuvem.\n",
    "</p>\n",
    "\n",
    "Para navegar neste universo de dados é necessário a compreensão de conceitos básicos que definem a organização e o funcionamento do MongoDB:\n",
    "\n",
    "- Coleções: Cada banco de dados no MongoDB pode conter diversas coleções (análogos das tabelas nas bases de dados relacional) sendo utilizadas para facilitar a organização e acesso dos dados;\n",
    "\n",
    "- Documentos: Cada documento no MongoDB é uma estrutura de dados no formato JSON que contem pares chave-valor, onde a chave identifica o atributo enquanto o valor representa o dado associado a esse atributo. No entanto, o valor pode ser também um par chave-valor o que permite a criação de documentos dentro de documentos que são denominados por documentos aninhados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Criação das Coleções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"justify\">\n",
    "De modo a realizar a transformação da base de dados do hospital (relacional) para o MongoDB, procedeu-se ao estabelecimento de uma conexão com uma base de dados MongoDB e criou-se coleções específicas utilizando a biblioteca pymongo em Python. A biblioteca pymongo fornece ferramentas para interagir com bases de dados MongoDB, facilitando a manipulação de dados e a gestão de coleções.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "A ligação ao servidor MongoDB foi estabelecida no endereço localhost na parta 27017. Após a conexção com o servidor realizou-se a conexção com a base de dados denominada \"Hospital\" que vai armazenar as várias coleções e documentos criados. Para esta base de dados foram criadas quatro coleções: Patients (pacientes), Services (serviços), Appointments (consultas) e Staff (funcionários).\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ligação ao servidor mongo\n",
    "client = MongoClient(\"localhost\", 27017)\n",
    "\n",
    "\n",
    "# Conexão à base de dados hospital, caso não exista é criada\n",
    "db = client.Hospital\n",
    "\n",
    "\n",
    "# Criação das várias coleções vazias\n",
    "Patients = db.create_collection(\"Patients\")\n",
    "Services = db.create_collection(\"Services\")\n",
    "Appointments = db.create_collection(\"Appointments\")\n",
    "Staff = db.create_collection(\"Staff\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Povoamento da coleções\n",
    "#### Coleção **Pacientes**\n",
    "\n",
    "<p align=\"justify\">\n",
    "A coleção pacientes foi criada com o intuito de facilitar o acesso a toda a informação relativa ao paciente permitindo o acesso aos dados acerca da seguradora, o histórico médico, entre outras informações associadas ao paciente de modo a reduzir a complexidade das consultas e aumentar a eficência do acesso aos dados.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Para criar esta coleção a partir da base de dados relacional é necessário realizar uma query que permita a extração da informação relativa a cada paciente que se encontra dispersa por várias entidades que estão centradas no paciente e que normalmente tendem a ser acessadas juntas.\n",
    "</p>\n",
    "\n",
    "Entidades envolvidas: \n",
    "* HOSPITAL_PATIENT\n",
    "* HOSPITAL_INSURANCE\n",
    "* HOSPITAL_MEDICAL_HISTORY\n",
    "* HOSPITAL_EMERGENCY_CONTACT\n",
    "\n",
    "<p align=\"justify\">\n",
    "Para se realizar a criação da coleção Patients (Pacientes), primeiramente é necessário proceder à extração dos dados das várias entidades. Com esse objetivo, definiu-se a função extract_data_from_oracle_patients, que começa por realizar a conecção à base de dados relacional e posteriormente são realizadas quatro consultas independentes para extrair a informação das entidades envolvidas. A primeira consulta, extrai a informação da entidade HOSPITAL_PATIENT que contém os dados demográficos do paciente, que inclui, o id do paciente, nome, tipo sanguíneo, telefone, entre outros. A segunda consulta retira a informação contida na entidade HOSPITAL_INSURANCE que é utilizada para amazenar os dados referentes à apolice e ao seguro do paciente. A terceira consulta coleta o historial médico associado ao pacinete que se encontra armazenado na tabela HOSPITAL_MEDICAL_HISTORY. A quarta e última consulta é utilizada para recolher os contactos de emergência associados a cada paciente (HOSPITAL_EMERGENCY_CONTACT).\n",
    "Os resultados de cada consulta realizada são então armazenados e posteriomente tratados e inseridos na coleção Patients através da utilização da função insert_data_to_mongodb_patients.\n",
    "Esta função recebe os dados extraídos de cada tabela e cria um documento para cada paciente que posteriomente é inserido na coleção.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_patients():\n",
    "    # Conecção à base de dados relacional e criação de cursor\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para a extração dos dados da entidade HOSPITAL_PATIENT\n",
    "    sql_patient = \"\"\"\n",
    "        SELECT \n",
    "            idpatient,     \n",
    "            patient_fname, \n",
    "            patient_lname, \n",
    "            blood_type, \n",
    "            phone,         \n",
    "            email,         \n",
    "            gender,        \n",
    "            policy_number, \n",
    "            BIRTHDAY\n",
    "        FROM\n",
    "            patient\n",
    "    \"\"\"\n",
    "    \n",
    "    # Armazenamento dos dados\n",
    "    cursor.execute(sql_patient)\n",
    "    patients = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_INSURANCE\n",
    "    sql_insurance = \"\"\"\n",
    "        SELECT \n",
    "            policy_number,  \n",
    "            provider,       \n",
    "            insurance_plan, \n",
    "            co_pay,         \n",
    "            coverage,       \n",
    "            maternity,      \n",
    "            dental,         \n",
    "            optical     \n",
    "        FROM \n",
    "            insurance\n",
    "    \"\"\"\n",
    "\n",
    "    # Armazenamento dos dados\n",
    "    cursor.execute(sql_insurance)\n",
    "    insurances = cursor.fetchall()\n",
    "    \n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_MEDICAL_HISTORY\n",
    "    sql_medical_history = \"\"\"\n",
    "        SELECT \n",
    "            record_id,   \n",
    "            record_date, \n",
    "            idpatient   \n",
    "        FROM \n",
    "            medical_history\n",
    "    \"\"\"\n",
    "\n",
    "    # Armazenamento dos dados\n",
    "    cursor.execute(sql_medical_history)\n",
    "    medical_histories = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_EMERGENCY_CONTACT\n",
    "    sql_emergency_contact = \"\"\"\n",
    "        SELECT \n",
    "            contact_name, \n",
    "            phone,        \n",
    "            relation,    \n",
    "            idpatient  \n",
    "        FROM \n",
    "            emergency_contact\n",
    "    \"\"\"\n",
    "    \n",
    "    # Armazenamento dos dados\n",
    "    cursor.execute(sql_emergency_contact)\n",
    "    emergency_contacts = cursor.fetchall()\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    cursor.close(); connection.close()\n",
    "\n",
    "    # Inserção dos dados na coleção MongoDB\n",
    "    insert_data_to_mongodb_patients(patients, insurances, medical_histories, emergency_contacts)\n",
    "\n",
    "\n",
    "def insert_data_to_mongodb_patients(patients, insurances, medical_histories, emergency_contacts):\n",
    "    # Conecção à coleção no MongoDB\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Patients']\n",
    "\n",
    "    # Converter insurances em um dicionário para acesso rápido\n",
    "    insurance_dict = {insurance[0]: insurance for insurance in insurances}\n",
    "\n",
    "    # Converter medical_histories e emergency_contacts em dicionários para acesso rápido\n",
    "    medical_history_dict = {}\n",
    "    for history in medical_histories:\n",
    "        if history[2] not in medical_history_dict:\n",
    "            medical_history_dict[history[2]] = []\n",
    "        medical_history_dict[history[2]].append(history)\n",
    "    \n",
    "    emergency_contact_dict = {}\n",
    "    for contact in emergency_contacts:\n",
    "        if contact[3] not in emergency_contact_dict:\n",
    "            emergency_contact_dict[contact[3]] = []\n",
    "        emergency_contact_dict[contact[3]].append(contact)\n",
    "\n",
    "    # Formatar os dados e inserir na coleção MongoDB\n",
    "    for patient in patients:\n",
    "        patient_id = patient[0]\n",
    "        policy_number = patient[7]\n",
    "\n",
    "        # Informações de seguro\n",
    "        insurance_data = insurance_dict.get(policy_number, [None]*8)\n",
    "        \n",
    "        # Informações de histórico médico\n",
    "        medical_history_data = medical_history_dict.get(patient_id, [])\n",
    "        \n",
    "        # Informações de contato de emergência\n",
    "        emergency_contact_data = emergency_contact_dict.get(patient_id, [])\n",
    "\n",
    "        patient_data = {\n",
    "            \"idpatient\": patient_id, \"patient_fname\": patient[1], \"patient_lname\": patient[2],\n",
    "            \"blood_type\": patient[3], \"phone\": patient[4], \"email\": patient[5],\n",
    "            \"gender\": patient[6], \"policy_number\": policy_number, \"BIRTHDAY\": patient[8],\n",
    "            \"insurance\": {\n",
    "                \"provider\": insurance_data[1], \"insurance_plan\": insurance_data[2],\n",
    "                \"co_pay\": insurance_data[3], \"coverage\": insurance_data[4], \"maternity\": insurance_data[5],\n",
    "                \"dental\": insurance_data[6], \"optical\": insurance_data[7]\n",
    "                },\n",
    "            \"medical_history\": [{\n",
    "                \"record_id\": history[0], \"record_date\": history[1]\n",
    "            } for history in medical_history_data],\n",
    "            \"emergency_contacts\": [{\n",
    "                \"contact_name\": contact[0], \"phone\": contact[1], \"relation\": contact[2]\n",
    "            } for contact in emergency_contact_data]\n",
    "        }\n",
    "        collection.insert_one(patient_data)\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    client.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extração dos dados do Oracle e inserção no MongoDB\n",
    "extract_data_from_oracle_patients()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Coleção **Consulta**\n",
    "\n",
    "<p align=\"justify\">\n",
    "A segunda coleção criada corresponde às concultas (Appointments) e foram mantidos numa coleção separada, uma vez que constituem um ponto de interação frequente e independente com o sistema, onde o acesso rápido e a atualização dos dados é crítico.\n",
    "</p>\n",
    "\n",
    "Entidades Incluídas: \n",
    "* HOSPITAL_APPOINTMENT\n",
    "\n",
    "<p align=\"justify\">\n",
    "O código desenvolvido para a criação desta coleção possui duas etapas principais. A primeira etapa corresponde à extração dos dados da tabela \"Appointments\", para isso criou-se a função extract_data_from_oracle_app que vai realizar a conecção com a base de dados relacional. Em seguida é realizada uma consulta que permite recuperar os dados armazenados na entidade incluída. A informação contida nesta tabela permite saber a data de agendamento da consulta (scheduled_on), a data da consulta (appointment_date) e a que horas será realizada (appointment_time), além disso, também permite saber quem é o médico responsável pela consulta (iddoctor) e o id do episódio clínico associado (idepisode). Posteriormente, o resultado da consulta é transformado em vários documentos do tipo JSON (cada documento corresponde a uma consulta) que são inseridos na coleção.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_app():\n",
    "\n",
    "    # Conecção à base de dados Oracle e criação do cursor\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_APPOINTMENT\n",
    "    sql_appointment = \"\"\"\n",
    "        SELECT \n",
    "            scheduled_on,\n",
    "            appointment_date,\n",
    "            appointment_time,\n",
    "            iddoctor,\n",
    "            idepisode\n",
    "        FROM \n",
    "            APPOINTMENT\n",
    "    \"\"\"\n",
    "\n",
    "    cursor.execute(sql_appointment)\n",
    "    appointments = cursor.fetchall()\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    cursor.close(); connection.close()\n",
    "\n",
    "    # Inserção dos dados na coleção\n",
    "    insert_data_to_mongodb_app(appointments)\n",
    "\n",
    "\n",
    "def insert_data_to_mongodb_app(appointments):\n",
    "    \n",
    "    # Conecção à base de dados Hospital e a coleção Appointments no MongoDB\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Appointments']\n",
    "\n",
    "    # Formatação e inserção do documento na coleção\n",
    "    for appointment in appointments:\n",
    "        appointment_data = {\n",
    "            \"scheduled_on\": appointment[0],\n",
    "            \"appointment_date\": appointment[1],\n",
    "            \"appointment_time\": appointment[2],\n",
    "            \"iddoctor\": appointment[3],\n",
    "            \"idepisode\": appointment[4],\n",
    "        }\n",
    "        collection.insert_one(appointment_data)\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    client.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extração e inserção dos dados na coleção\n",
    "extract_data_from_oracle_app()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Coleção **Serviços**\n",
    "\n",
    "<p align=\"justify\">\n",
    "Com o intuito de facilitar o rastreamento do atendimento de um determinado paciente e da faturação criou-se a coleção \"Services\", uma vez que um episódio de atendimento a um paciente normalmente envolve a alocação de um quarto, exames laboratorias e despesas hospitalares que necessitam de ser geridas de forma eficiente e ponderada de modo a garantir o perfeito funcionamento do hospital e o bom atendimento dos pacientes evitando constrangimentos no serviço ou possíveis cenários de negligência.\n",
    "</p>\n",
    "\n",
    "Entidades Incluídas: \n",
    "* HOSPITAL_EPISODE\n",
    "* HOSPITAL_ROOM\n",
    "* HOSPITAL_BILL \n",
    "* HOSPITAL_LAB_SCREENING\n",
    "\n",
    "<p align=\"justify\">\n",
    "Tal como para as coleções anteriores, foram definidas duas funções de modo a auxiliar a passagem dos dados da base de dados relacional para o MongoDB. A função **extract_data_from_oracle_services** é utilizada para realizar a extração dos dados e posteriomente chama a segunda função que é responsável pelo tratamento e inserção dos dados na coleção realizando assim a migração para o MongoDB. A função de extração realiza 4 consultas SQL separadas para recuperar os dados de tabelas relacionadas. A primeria consulta coleta as informações básicas de um determinado atendimento tal como o id do espisódio e o id do paciente da tabela HOSPITAL_EPISODE. A segunda consulta é realizada com o objetivo de extrair a informação relativa ao quarto utilizado (HOSPITAL_ROOM). De modo a coletar a informação relativa à faturação de um determinado espisódio, realizou-se uma terceira consulta que incide sobre a entidade HOSPITAL_BILL, uma vez que nesta tabela são armazenados todos os dados referentes a uma determinada fatura incluindo o estado, isto é, se a fatura foi líquidada ou se o hospital ainda agurada o pagamento. Por fim, a última consulta realizada, vai recolher as informações relativas aos exames laboratoriais que inclui, o custo, a data do exame e o id do técnico. Os resultados das consultas foram armazenados e posteriomente utilizados na segunda função que realiza a criação dos vários documentos tipo JSON que posteriomente são inseridos na coleção \"Services\". É importante ressalvar que antes de se realizar a inserção de um novo documento, realiza-se a limpeza da coleção de modo a evitar a existência de duplicados.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_services():\n",
    "    # Conexão à bases de dados Oracle\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_EPISODE\n",
    "    sql_episode = \"\"\"\n",
    "        SELECT \n",
    "            idepisode,\n",
    "            patient_idpatient\n",
    "        FROM \n",
    "            episode\n",
    "    \"\"\"\n",
    "\n",
    "    # Armazenamento da consulta\n",
    "    cursor.execute(sql_episode)\n",
    "    episodes = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_ROOM\n",
    "    sql_room = \"\"\"\n",
    "        SELECT \n",
    "            r.idroom,\n",
    "            r.room_type,\n",
    "            r.room_cost,\n",
    "            h.idepisode\n",
    "        FROM \n",
    "            room r\n",
    "        INNER JOIN hospitalization h ON r.idroom = h.room_idroom\n",
    "    \"\"\"\n",
    "    \n",
    "    # Armazenamento da consulta\n",
    "    cursor.execute(sql_room)\n",
    "    rooms = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_BILL\n",
    "    sql_bill = \"\"\"\n",
    "        SELECT \n",
    "            b.idbill,\n",
    "            b.room_cost,\n",
    "            b.test_cost,\n",
    "            b.other_charges,\n",
    "            b.total,\n",
    "            b.idepisode,\n",
    "            b.registered_at,\n",
    "            b.payment_status\n",
    "        FROM \n",
    "            bill b\n",
    "        INNER JOIN hospitalization h ON b.idepisode = h.idepisode\n",
    "    \"\"\"\n",
    "    \n",
    "    # Armazenamento da consulta\n",
    "    cursor.execute(sql_bill)\n",
    "    bills = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITAL_LAB_SCREENING\n",
    "    sql_lab_screening = \"\"\"\n",
    "        SELECT \n",
    "            ls.lab_id,\n",
    "            ls.test_cost,\n",
    "            ls.test_date,\n",
    "            ls.idtechnician,\n",
    "            h.idepisode\n",
    "        FROM \n",
    "            lab_screening ls\n",
    "        INNER JOIN hospitalization h ON ls.episode_idepisode = h.idepisode\n",
    "    \"\"\"\n",
    "\n",
    "    # Armazenamento da consulta\n",
    "    cursor.execute(sql_lab_screening)\n",
    "    lab_screenings = cursor.fetchall()\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    cursor.close(); connection.close()\n",
    "\n",
    "    # Inserção dos dados na coleção\n",
    "    insert_data_to_mongodb_services(episodes, rooms, bills, lab_screenings)\n",
    "\n",
    "\n",
    "def insert_data_to_mongodb_services(episodes, rooms, bills, lab_screenings):\n",
    "    # Conexão à base de dados e à respetiva coleção\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Services']\n",
    "\n",
    "    # Remoção de duplicados\n",
    "    collection.delete_many({})\n",
    "\n",
    "    # Inserção dos dados na coleção\n",
    "    for episode in episodes:\n",
    "        episode_data = {\n",
    "            \"idepisode\": episode[0], \"patient_idpatient\": episode[1],\n",
    "            \"room\": [], \"bill\": [], \"lab_screening\": []\n",
    "        }\n",
    "        for room in rooms:\n",
    "            if room[3] == episode[0]:\n",
    "                episode_data[\"room\"].append(\n",
    "                    {\"idroom\": room[0], \"room_type\": room[1],\"room_cost\": room[2]}\n",
    "                    )\n",
    "        for bill in bills:\n",
    "            if bill[5] == episode[0]:\n",
    "                episode_data[\"bill\"].append(\n",
    "                    {\"idbill\": bill[0], \"room_cost\": bill[1], \"test_cost\": bill[2],\n",
    "                    \"other_charges\": bill[3], \"total\": bill[4], \"registered_at\": bill[6],\n",
    "                    \"payment_status\": bill[7]}\n",
    "                    )\n",
    "                \n",
    "        for lab_screening in lab_screenings:\n",
    "            if lab_screening[4] == episode[0]:\n",
    "                episode_data[\"lab_screening\"].append(\n",
    "                    {\"lab_id\": lab_screening[0], \"test_cost\": lab_screening[1],\n",
    "                    \"test_date\": lab_screening[2], \"idtechnician\": lab_screening[3]}\n",
    "                    )\n",
    "                \n",
    "        collection.insert_one(episode_data)\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    client.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extração e inserção dos dados na respetiva coleção\n",
    "extract_data_from_oracle_services()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Coleção **Staff**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"justify\">\n",
    "Para promover uma gestão eficiente e integrada dos profissionais de saúde dentro do ambiente hospitalar, foi criada a coleção \"Staff\" na base de dados da MongoDB. Esta coleção facilita a organização e o acesso a informação detalhadas de cada funcionário, essenciais para operações diárias, planeamento de recursos humanos e resposta rápida a necessidades operacionais e clínicas. A coleção engloba dados de médicos, enfermeiros e técnicos, consolidando informações que são críticas para o bom funcionamento do hospital e para manter um alto padrão de atendimento ao paciente.\n",
    "</p>\n",
    "\n",
    "Entidades Incluídas:\n",
    "* HOSPITAL_DOCTOR\n",
    "* HOSPITAL_NURSE\n",
    "* HOSPITAL_TECHNICIAN\n",
    "\n",
    "<p align=\"justify\">\n",
    "As funções extract_data_from_oracle e insert_data_to_mongodb foram desenvolvidas para auxiliar a migração dos dados do sistema de base de dados relacional Oracle para o MongoDB. A função extract_data_from_oracle, começa com queries para coletar dados de cada entidade relevante. Para os médicos, enfermeiros e técnicos, são extraídos detalhes como identificação, nome, datas de início e término de vínculo, e-mail, endereço, e outras informações profissionais. Para além disso, também são coletados dados sobre a participação desses profissionais em episódios de tratamento, internações, consultas e exames. Estas informações são fundamentais para entender a carga de trabalho e as responsabilidades específicas de cada membro da equipa. Após a extração, os dados são tratados e formatados adequadamente antes de serem inseridos na coleção \"Staff\" no MongoDB, onde cada documento representa um funcionário, com campos que refletem as suas qualificações, experiência e papel dentro do hospital.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle():\n",
    "    # Conexão ao Oracle\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de STAFF\n",
    "    sql_staff = \"\"\"\n",
    "        SELECT \n",
    "            EMP_ID,\n",
    "            EMP_FNAME,\n",
    "            EMP_LNAME,\n",
    "            DATE_JOINING,\n",
    "            DATE_SEPERATION,\n",
    "            EMAIL,\n",
    "            ADDRESS,\n",
    "            SSN,\n",
    "            IDDEPARTMENT,\n",
    "            IS_ACTIVE_STATUS\n",
    "        FROM \n",
    "            STAFF\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_staff)\n",
    "    staff = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de NURSE\n",
    "    sql_nurse = \"SELECT STAFF_EMP_ID FROM NURSE\"; cursor.execute(sql_nurse)\n",
    "    nurses = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de DOCTOR\n",
    "    sql_doctor = \"SELECT EMP_ID FROM DOCTOR\"; cursor.execute(sql_doctor)\n",
    "    doctors = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de TECHNICIAN\n",
    "    sql_technician = \"SELECT STAFF_EMP_ID FROM TECHNICIAN\"; cursor.execute(sql_technician)\n",
    "    technicians = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de HOSPITALIZATION\n",
    "    sql_hospitalization = \"SELECT RESPONSIBLE_NURSE, IDEPISODE FROM HOSPITALIZATION\"; cursor.execute(sql_hospitalization)\n",
    "    hospitalizations = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de APPOINTMENT\n",
    "    sql_appointment = \"SELECT IDDOCTOR, IDEPISODE FROM APPOINTMENT\"; cursor.execute(sql_appointment)\n",
    "    appointments = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extração dos dados de LAB_SCREENING\n",
    "    sql_lab_screening = \"SELECT IDTECHNICIAN, EPISODE_IDEPISODE FROM LAB_SCREENING\"; cursor.execute(sql_lab_screening)\n",
    "    lab_screenings = cursor.fetchall()\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    cursor.close(); connection.close()\n",
    "\n",
    "    # Inserção dos dados\n",
    "    insert_data_to_mongodb(staff, nurses, doctors, technicians, hospitalizations, appointments, lab_screenings)\n",
    "\n",
    "\n",
    "def insert_data_to_mongodb(staffs, nurses, doctors, technicians, hospitalizations, appointments, lab_screenings):\n",
    "    # Conexão à bases de dados e respetiva coleção\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Staff']\n",
    "\n",
    "    # Conversão de listas em conjuntos para pesquisa mais rápida\n",
    "    nurse_set = {nurse[0] for nurse in nurses}\n",
    "    doctor_set = {doctor[0] for doctor in doctors}\n",
    "    technician_set = {technician[0] for technician in technicians}\n",
    "\n",
    "    # Criação de dicionários para pesquisa de episódios\n",
    "    nurse_episodes = {}\n",
    "    for hosp in hospitalizations:\n",
    "        if hosp[0] in nurse_episodes: nurse_episodes[hosp[0]].append(hosp[1])\n",
    "        else: nurse_episodes[hosp[0]] = [hosp[1]]\n",
    "    \n",
    "    doctor_episodes = {}\n",
    "    for appt in appointments:\n",
    "        if appt[0] in doctor_episodes: doctor_episodes[appt[0]].append(appt[1])\n",
    "        else: doctor_episodes[appt[0]] = [appt[1]]\n",
    "    \n",
    "    technician_episodes = {}\n",
    "    for lab in lab_screenings:\n",
    "        if lab[0] in technician_episodes: technician_episodes[lab[0]].append(lab[1])\n",
    "        else: technician_episodes[lab[0]] = [lab[1]]\n",
    "\n",
    "    # Formatação dos dados e inserção na coleção\n",
    "    for staff in staffs:\n",
    "        emp_id = staff[0]\n",
    "        type_ = \"none\"\n",
    "        idepisodes = []\n",
    "\n",
    "        if emp_id in nurse_set:\n",
    "            type_ = \"nurse\"\n",
    "            idepisodes = nurse_episodes.get(emp_id, [])\n",
    "        elif emp_id in doctor_set:\n",
    "            type_ = \"doctor\"\n",
    "            idepisodes = doctor_episodes.get(emp_id, [])\n",
    "        elif emp_id in technician_set:\n",
    "            type_ = \"technician\"\n",
    "            idepisodes = technician_episodes.get(emp_id, [])\n",
    "\n",
    "        staff_data = {\n",
    "            \"_id\": emp_id, \"firstName\": staff[1], \"lastName\": staff[2],\n",
    "            \"joiningDate\": staff[3], \"separationDate\": staff[4], \"email\": staff[5],\n",
    "            \"address\": staff[6], \"ssn\": staff[7], \"departmentId\": staff[8],\n",
    "            \"isActiveStatus\": staff[9], \"type\": type_, \"idepisodes\": idepisodes\n",
    "        }\n",
    "        collection.insert_one(staff_data)\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    client.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extração e inserção dos dados na coleção staff\n",
    "extract_data_from_oracle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexação MongoDB\n",
    "\n",
    "<p align=\"justify\">\n",
    "A indexação no MongoDB é uma técnica fundamental para aumentar de forma considerável a eficiência das consultas. Sem a presença de índices, o MongoDB necessita de percorrer todos os documentos de uma determinada coleção de modo a identificar todos aqueles que correspondem aos critérios da consulta, resultando numa operação altamente ineficiente e que demanda o processamento de um grande volume de dados.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Os índices são estruturas de dados especiais que armazenam uma pequena porção dos conjuntos de dados, facilitando o processamento das consultas. Os dados armazenados correspondem a valores de campos específicos ou de conjuntos de campos, ordenados conforme especificado no índice, que permitem a localização rapida dos documentos correspondentes sem proceder à verificação indivual de cada documento, melhorando significativamente a performance das operações de leitura.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "O código apresentado em baixo, demonstra como é que se realiza a criação de índices com o intuito de otimizar as consultas nessas coleções específicas, essenciais para a gestão eficiente em contexto hospitalar. \n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Para isso selecionou-se as quatro coleções existentes na nossa base de dados: 'Patients', 'Appointments', 'Services' e 'Staff'. Cada coleção armazena dados diferentes e relevantes para a operação do hospital. Por exemplo, 'Patients' contém informações sobre os pacientes, 'Appointments' guarda dados sobre as consultas agendadas, 'Services' registra informações sobre os serviços médicos prestados e 'Staff' detém detalhes sobre os funcionários do hospital.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Em todas as coleções, cada documento é identificado por um \"_id\" único gerado automaticamente pelo MongoDB. Além disso, na coleção 'Patients', os índices são criados para facilitar buscas por data de nascimento e género e para o número de seguro. Para a coleção 'Appointments', os índices são estabelecidos para a data agendada e uma combinação do médico e da data da consulta, permitindo que o pessoal hospitalar organize e recupere eficientemente as agendas dos médicos e as datas das consultas dos pacientes. A coleção 'Services' utiliza índices para episódios de tratamento e identificação de faturas, o que é vital para o acompanhamento financeiro e clínico dentro do hospital. Finalmente, na coleção 'Staff', são criados índices para o departamento ao qual pertencem e o tipo de função que exercem. Isso permite que o departamento de recursos humanos do hospital gerencie seu pessoal de forma mais eficaz, desde a alocação de tarefas até a conformidade regulatória e administrativa.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conexão ao MongoDB\n",
    "client = MongoClient('mongodb://localhost:27017/')\n",
    "db = client['Hospital']\n",
    "\n",
    "\n",
    "# Seleção das coleções\n",
    "collection_p = db['Patients']\n",
    "collection_a = db['Appointments']\n",
    "collection_s = db['Services']\n",
    "collection_sa = db['Staff']\n",
    "\n",
    "\n",
    "# Criação dos índices para cada coleção\n",
    "# Índices para a coleção Patients\n",
    "collection_p.create_index([(\"BIRTHDAY\", 1), (\"gender\", 1)])  # Índice composto para buscas por data de nascimento e gênero\n",
    "collection_p.create_index([(\"policy_number\", 1)])  # Índice para número de seguro\n",
    "\n",
    "\n",
    "# Índices para a coleção Appointments\n",
    "collection_a.create_index([(\"scheduled_on\", 1)])  # Índice para data agendada\n",
    "collection_a.create_index([(\"iddoctor\", 1), (\"appointment_date\", 1)])  # Índice composto para consultas por médico e data\n",
    "\n",
    "\n",
    "# Índices para a coleção Services\n",
    "collection_s.create_index([(\"idbill\", 1)])  # Índice para identificação da fatura\n",
    "collection_s.create_index([(\"lab_id\", 1)])  # Índice único para identificação do exame de laboratório\n",
    "\n",
    "\n",
    "# Índices para a coleção Staff\n",
    "collection_sa.create_index([(\"departmentId\", 1)])  # Índice para identificação do departamento\n",
    "collection_sa.create_index([(\"type\", 1)])  # Índice para tipo de funcionário (nurse, doctor, technician)\n",
    "\n",
    "\n",
    "# Encerramento da conexão\n",
    "client.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agregação e Views no MongoDB -> explicar código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"justify\">\n",
    "No MongoDB, o framework de agregação é uma ferramenta poderosa que permite processar dados e realizar operações complexas de transformação, semelhante a uma pipeline, onde os dados passam por várias etapas de processamento antes de produzir o resultado final. Essa capacidade de agregação é fundamental para realizar análises profundas e extração de insights significativos de grandes volumes de dados, especialmente útil em ambientes que demandam análise rápida e eficiente, como big data e análise de dados em tempo real.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Uma pipeline de agregação no MongoDB é composta por vários estágios, onde cada estágio transforma os documentos à medida que eles passam pela pipeline. Os estágios podem incluir operações como filtragem ($match), agrupamento ($group), projeção ($project), ordenação ($sort), limitação ($limit), entre outros. Esses estágios são configurados de forma sequencial, e o output de um estágio é passado como input para o próximo, permitindo a criação de processamentos complexos e customizados. Por exemplo, pode-se começar com um estágio de match para filtrar documentos baseados em critérios específicos, seguido de um estágio de group para agrupar esses documentos por um ou mais campos, e talvez terminar com um estágio de sort para ordenar os resultados por algum critério de interesse.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Além das agregações, o MongoDB também suporta a criação de \"views\" que são, de certa forma, semelhantes às views em bases de dados relacionais. Uma view no MongoDB é uma representação virtual de um resultado de uma agregação que pode ser tratada quase da mesma forma que se trata uma coleção regular. Uma vez criada, a view pode ser consultada como se fosse uma coleção, mas sem ocupar espaço adicional para armazenamento, pois os dados na view são gerados dinamicamente a partir da coleção original sempre que a view é acessada. Isso é particularmente útil para expor um subconjunto de dados ou uma transformação específica de dados sem duplicar informações na base de dados, facilitando manutenções e atualizações ao isolar a lógica de transformação de dados em um único local.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "As views são definidas a partir de uma pipeline de agregação e são armazenadas na base de dados como uma definição, não como dados físicos. Quando um usuário consulta uma view, o MongoDB executa a pipeline de agregação associada para gerar o resultado em tempo real. Isso proporciona uma camada adicional de abstração e segurança, permitindo que os administradores limitem a visibilidade dos dados aos usuários finais, mostrando apenas os dados transformados e relevantes.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "Assim, enquanto as agregações fornecem um método dinâmico e poderoso para analisar e transformar dados em MongoDB, as views oferecem uma maneira eficiente e segura de acessar e apresentar esses dados, mantendo a integridade e o controle sobre a informação original armazenada na base de dados. Ambas as funcionalidades, quando utilizadas adequadamente, permitem que os desenvolvedores e analistas de dados maximizem a utilidade dos dados armazenados no MongoDB, criando soluções eficientes e escaláveis para gestão de dados e análise.\n",
    "</p>\n",
    "<p align=\"justify\">\n",
    "O módulo não inclui pacotes para criação direta das views, ou seja, isso apenas é conseguido diretamente na base de dados. No entanto, é possível criar agregações que podem dar informações úteis, como exemplo, explorar se um medico deste hospital também é um paciente do mesmo. Para isso, criou-se uma agregação que compara os primeiro e último nomes dos médicos e dos pacientes da loja online.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Médicos que já foram pacientes no hospital\n",
    "\n",
    "O código apresentado abaixo serve realizar uma agregação que identifica quais médicos também são pacientes no hospital. Para isso, é definida uma pipeline de agregação MongoDB onde uma sequência de estágios de processamento de dados que são aplicados aos documentos na coleção.\n",
    "\n",
    "a. $match: Filtra os documentos na coleção \"Patients\" para encontrar aqueles cujo tipo é \"doctor\", ou seja, médicos.\n",
    "\n",
    "b. $lookup: Realiza uma operação de junção com a mesma coleção \"Patients\" para encontrar documentos que tenham um campo \"_id\" correspondente ao campo \"idpatient\" nos documentos filtrados no estágio anterior. Isso associa os médicos aos seus registros de paciente.\n",
    "\n",
    "c. $match: Filtra novamente os documentos resultantes da junção para encontrar aqueles que têm informações de paciente associadas, ou seja, médicos que também são pacientes.\n",
    "\n",
    "d. $project: Projeta os campos desejados para o resultado final. Aqui, apenas os campos \"_id\", \"firstName\", \"lastName\" são mantidos, e um novo campo \"isDoctorPatient\" é adicionado usando a expressão condicional \"$cond\" para indicar se o médico é também um paciente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aggregate para descobrir que medicos também já foram pacientes no hospital\n",
    "def aggregate_doctor_patients():\n",
    "    try:\n",
    "        # Conexão com o MongoDB\n",
    "        client = MongoClient('mongodb://localhost:27017/')\n",
    "        db = client['Hospital']\n",
    "        collection = db['Patients']\n",
    "\n",
    "        # Agregação para encontrar médicos que também são pacientes\n",
    "        pipeline = [\n",
    "            {\n",
    "                \"$match\": {\n",
    "                    \"type\": \"doctor\"\n",
    "                }\n",
    "            },\n",
    "            {\n",
    "                \"$lookup\": {\n",
    "                    \"from\": \"Patients\",\n",
    "                    \"localField\": \"_id\",\n",
    "                    \"foreignField\": \"idpatient\",\n",
    "                    \"as\": \"patient_info\"\n",
    "                }\n",
    "            },\n",
    "            {\n",
    "                \"$match\": {\n",
    "                    \"patient_info\": {\"$ne\": []}\n",
    "                }\n",
    "            },\n",
    "            {\n",
    "                \"$project\": {\n",
    "                    \"_id\": 1,\n",
    "                    \"firstName\": 1,\n",
    "                    \"lastName\": 1,\n",
    "                    \"isDoctorPatient\": {\"$cond\": {\"if\": {\"$isArray\": \"$patient_info\"}, \"then\": True, \"else\": False}}\n",
    "                }\n",
    "            }\n",
    "        ]\n",
    "\n",
    "        # Executar a agregação\n",
    "        result = list(collection.aggregate(pipeline))\n",
    "\n",
    "        # Exibir o resultado\n",
    "        if not result:\n",
    "            print(\"Não há nenhum médico que seja paciente\")\n",
    "        else:\n",
    "            for doctor_patient in result:\n",
    "                print(doctor_patient)\n",
    "    \n",
    "    except Exception as e:\n",
    "        print(f\"Ocorreu um erro: {e}\")\n",
    "\n",
    "    finally:\n",
    "        # Fechar conexão\n",
    "        if client:\n",
    "            client.close()\n",
    "\n",
    "# Chamada da função para fazer a agregação\n",
    "aggregate_doctor_patients()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Receitas do hospital\n",
    "\n",
    "O seguinte código serve para realizar uma agregação que calcula as receitas do hospital a partir das faturas dos serviços. Para isso, é definida uma pipeline de agregação MongoDB onde uma sequência de estágios de processamento de dados que são aplicados aos documentos na coleção.\n",
    "\n",
    "a. $unwind: Este estágio desnormaliza o array de faturas dentro de cada documento, ou seja, para cada documento com múltiplas faturas, cria uma entrada separada para cada fatura. Isso é necessário para que cada fatura possa ser tratada individualmente nos estágios seguintes.\n",
    "\n",
    "b. $project: Este estágio projeta apenas os campos relevantes das faturas. O campo \"_id\" é excluído, e os campos \"idepisode\", \"patient_idpatient\" e \"bill\" são mantidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aggregate para calcular as receitas do hospital\n",
    "def aggregate_services_bills():\n",
    "    try:\n",
    "        # Conexão com o MongoDB\n",
    "        client = MongoClient('mongodb://localhost:27017/')\n",
    "        db = client['Hospital']\n",
    "        collection = db['Services']\n",
    "\n",
    "        # Agregação para extrair as faturas (bills) dentro da coleção services\n",
    "        pipeline = [\n",
    "            {\n",
    "                \"$unwind\": \"$bill\"  # Desnormaliza o array de faturas\n",
    "            },\n",
    "            {\n",
    "                \"$project\": {  # Projeta apenas os campos relevantes das faturas\n",
    "                    \"_id\": 0,  # Exclui o _id padrão do MongoDB\n",
    "                    \"idepisode\": 1,\n",
    "                    \"patient_idpatient\": 1,\n",
    "                    \"bill\": 1\n",
    "                }\n",
    "            }\n",
    "        ]\n",
    "\n",
    "        # Executar a agregação\n",
    "        result = list(collection.aggregate(pipeline))\n",
    "\n",
    "        # Exibir o resultado\n",
    "        for service in result:\n",
    "            print(service)\n",
    "    \n",
    "    except Exception as e:\n",
    "        print(f\"Ocorreu um erro: {e}\")\n",
    "\n",
    "    finally:\n",
    "        # Fechar conexão\n",
    "        if client:\n",
    "            client.close()\n",
    "\n",
    "# Chamada da função para fazer a agregação\n",
    "aggregate_services_bills()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Número de pacientes por faixa etária\n",
    "\n",
    "As funções definidas em baixo realizam uma agregação que calcula o número de pacientes por faixa etária.Para isso, são definidas dis funcoes e uma pipeline de agregação MongoDB onde uma sequência de estágios de processamento de dados que são aplicados aos documentos na coleção.\n",
    " \n",
    "Função calculate_age: Esta função calcula a idade com base na data de nascimento fornecida. Ela recebe a data de nascimento como entrada e retorna a idade calculada em anos.\n",
    "\n",
    "Função aggregate_patients_by_age_range: Esta função executa a agregação no MongoDB para calcular o número de pacientes por faixa etária.\n",
    "\n",
    "a. $project: Este estágio projeta um novo campo \"age\", que é calculado subtraindo o ano atual do ano de nascimento de cada paciente. Utiliza a função datetime.utcnow() para obter a data atual e a função calculate_age para calcular a idade.\n",
    "\n",
    "b. $bucket: Este estágio agrupa os documentos por faixa etária. Ele divide os pacientes em faixas etárias pré-definidas (0-18, 19-35, 36-50, 51-65, 66-100, acima de 100) e conta o número de pacientes em cada faixa. Faixas que não se enquadram nos limites especificados são agrupadas na faixa \"100+\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aggregate do número de pacientes por faixa etária\n",
    "def calculate_age(birth_date):\n",
    "    today = datetime.utcnow()\n",
    "    age = today.year - birth_date.year - ((today.month, today.day) < (birth_date.month, birth_date.day))\n",
    "    return age\n",
    "\n",
    "def aggregate_patients_by_age_range():\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Patients']\n",
    "\n",
    "    pipeline = [\n",
    "        {\n",
    "            \"$project\": {\n",
    "                \"age\": {\n",
    "                    \"$subtract\": [\n",
    "                        {\"$year\": datetime.utcnow()},\n",
    "                        {\"$year\": \"$BIRTHDAY\"}\n",
    "                    ]\n",
    "                }\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$bucket\": {\n",
    "                \"groupBy\": \"$age\",\n",
    "                \"boundaries\": [0, 18, 35, 50, 65, 100],\n",
    "                \"default\": \"100+\",\n",
    "                \"output\": {\n",
    "                    \"count\": {\"$sum\": 1}\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "\n",
    "    result = collection.aggregate(pipeline)\n",
    "\n",
    "    for age_range in result:\n",
    "        print(age_range)\n",
    "\n",
    "    client.close()\n",
    "\n",
    "# Chamada da função para fazer a agregação\n",
    "aggregate_patients_by_age_range()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Número de consultas por médico\n",
    "\n",
    "Este código realizar uma agregação que conta o número de consultas para cada médico no banco de dados, enriquecendo os resultados com informações adicionais sobre os médicos, como seus nomes.Para isso, são definidas dis funcoes e uma pipeline de agregação MongoDB onde uma sequência de estágios de processamento de dados que são aplicados aos documentos na coleção.\n",
    " \n",
    "a. $group: Este estágio agrupa os documentos por \"iddoctor\", que é o identificador único de cada médico, e calcula o total de consultas para cada médico usando a expressão \"$sum\".\n",
    "\n",
    "b. $lookup: Este estágio realiza uma operação de junção com a coleção \"Staff\" para adicionar informações adicionais sobre os médicos. Ele compara o campo \"_id\" do estágio anterior com o campo \"_id\" da coleção \"Staff\" para encontrar correspondências e adiciona as informações encontradas na matriz \"doctor_info\".\n",
    "\n",
    "c. $project: Este estágio projeta os campos desejados para o resultado final. Ele mantém o total de consultas (\"total_appointments\"), o ID do médico (\"doctor_id\"), o nome do médico (\"doctor_name\") e o sobrenome do médico (\"doctor_lastname\"). Os nomes e sobrenomes são extraídos da matriz \"doctor_info\" usando a função \"$arrayElemAt\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aggregate para contar o número de consultas por médico\n",
    "\n",
    "def aggregate_appointments_by_doctor():\n",
    "    # Conexão com o MongoDB\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Appointments']\n",
    "\n",
    "    # Pipeline de agregação para contar o número de consultas por médico\n",
    "    pipeline = [\n",
    "        {\n",
    "            \"$group\": {\n",
    "                \"_id\": \"$iddoctor\",\n",
    "                \"total_appointments\": {\"$sum\": 1}\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$lookup\": {\n",
    "                \"from\": \"Staff\",\n",
    "                \"localField\": \"_id\",\n",
    "                \"foreignField\": \"_id\",\n",
    "                \"as\": \"doctor_info\"\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$project\": {\n",
    "                \"doctor_id\": \"$_id\",\n",
    "                \"total_appointments\": 1,\n",
    "                \"doctor_name\": {\"$arrayElemAt\": [\"$doctor_info.firstName\", 0]},\n",
    "                \"doctor_lastname\": {\"$arrayElemAt\": [\"$doctor_info.lastName\", 0]}\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "\n",
    "    # Executar a agregação\n",
    "    result = list(collection.aggregate(pipeline))\n",
    "\n",
    "    # Exibir o resultado\n",
    "    for appointment_count in result:\n",
    "        print(appointment_count)\n",
    "\n",
    "    # Fechar conexão\n",
    "    client.close()\n",
    "\n",
    "# Chamada da função para fazer a agregação\n",
    "aggregate_appointments_by_doctor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Número de consultas por médico, incluindo o número de consultas por mês para cada médico\n",
    "Por fim, este último aggregate é utilizado para contar o número de consultas para cada médico no base de dados, incluindo informações sobre o mês e o ano de cada consulta.Para isso, são definidas dis funcoes e uma pipeline de agregação MongoDB onde uma sequência de estágios de processamento de dados que são aplicados aos documentos na coleção.\n",
    " \n",
    "a. $addFields: Este estágio adiciona novos campos aos documentos da coleção. Ele cria dois novos campos, \"appointment_month\" e \"appointment_year\", que armazenam o mês e o ano da data da consulta, respectivamente.\n",
    "\n",
    "b. $group: Este estágio agrupa os documentos por \"iddoctor\" (identificador único do médico), \"month\" (mês da consulta) e \"year\" (ano da consulta), calculando o total de consultas para cada combinação de médico, mês e ano usando a expressão \"$sum\".\n",
    "\n",
    "c. $lookup: Este estágio realiza uma operação de junção com a coleção \"Staff\" para adicionar informações adicionais sobre os médicos. Ele compara o campo \"_id\" do estágio anterior com o campo \"_id\" da coleção \"Staff\" para encontrar correspondências e adiciona as informações encontradas na matriz \"doctor_info\".\n",
    "\n",
    "d. $project: Este estágio projeta os campos desejados para o resultado final. Ele mantém o ID do médico (\"doctor_id\"), o mês da consulta (\"month\"), o ano da consulta (\"year\"), o total de consultas (\"total_appointments\"), o nome do médico (\"doctor_name\") e o sobrenome do médico (\"doctor_lastname\"). Os nomes e sobrenomes são extraídos da matriz \"doctor_info\" usando a função \"$arrayElemAt\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aggregate para contar as consultas por médico, incluindo o número de consultas por mês para cada médico\n",
    "def aggregate_appointments_by_month_and_doctor():\n",
    "    # Conexão com o MongoDB\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    collection = db['Appointments']\n",
    "\n",
    "    # Pipeline de agregação para contar o número de consultas por médico e mês\n",
    "    pipeline = [\n",
    "        {\n",
    "            \"$addFields\": {\n",
    "                \"appointment_month\": {\"$month\": \"$appointment_date\"},\n",
    "                \"appointment_year\": {\"$year\": \"$appointment_date\"}\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$group\": {\n",
    "                \"_id\": {\n",
    "                    \"iddoctor\": \"$iddoctor\",\n",
    "                    \"month\": \"$appointment_month\",\n",
    "                    \"year\": \"$appointment_year\"\n",
    "                },\n",
    "                \"total_appointments\": {\"$sum\": 1}\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$lookup\": {\n",
    "                \"from\": \"Staff\",\n",
    "                \"localField\": \"_id.iddoctor\",\n",
    "                \"foreignField\": \"_id\",\n",
    "                \"as\": \"doctor_info\"\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$project\": {\n",
    "                \"doctor_id\": \"$_id.iddoctor\",\n",
    "                \"month\": \"$_id.month\",\n",
    "                \"year\": \"$_id.year\",\n",
    "                \"total_appointments\": 1,\n",
    "                \"doctor_name\": {\"$arrayElemAt\": [\"$doctor_info.firstName\", 0]},\n",
    "                \"doctor_lastname\": {\"$arrayElemAt\": [\"$doctor_info.lastName\", 0]}\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "\n",
    "    # Executar a agregação\n",
    "    result = list(collection.aggregate(pipeline))\n",
    "\n",
    "    # Exibir o resultado\n",
    "    for appointment_count in result:\n",
    "        print(appointment_count)\n",
    "\n",
    "    # Fechar conexão\n",
    "    client.close()\n",
    "\n",
    "# Chamada da função para fazer a agregação\n",
    "aggregate_appointments_by_month_and_doctor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Triggers MongoDB\n",
    "\n",
    "Os triggers no MongoDB são utilizados para responder a eventos específicos que ocorrem na base de dados, permitindo que o código seja executado de forma automática em resposta a mudanças nos dados que podem pasar por, inserções, atualizações ou exclusões. A utilização de trigers é um aspeto essêncial para a manutenção da consistência dos dados podendo ainda ser utilizados para realizar cálculos, envio notificações entre outras aplicações, sem a necessidade de intervenção manual.\n",
    "\n",
    "Tipos de Triggers no MongoDB Atlas:\n",
    "- ⁠Database Triggers: Executam funções em resposta a mudanças em documentos em uma coleção.\n",
    "- ⁠Scheduled Triggers: Executam funções em intervalos de tempo específicos.\n",
    "- ⁠Authentication Triggers: Executam funções em resposta a eventos de autenticação, como criação de usuários ou login.\n",
    "\n",
    "Para a nossa base dados, procedeu-se à criação de dois triggers:\n",
    "\n",
    "O trigger 1, em resumo, corresponde a um manipulador de eventos que é acionado quando um novo documento é inserido em uma coleção. O trigger regista o ID do novo documento e fornece um local para adicionar lógica conforme necessário. Este tipo de função é útil para reagir dinamicamente a mudanças nos dados do banco de dados, permitindo automatizar tarefas e manter outros sistemas ou serviços sincronizados.\n",
    "\n",
    "![Trigger1](triggers_mongo/trigger1.jpg)\n",
    "<figcaption>Figura 2- Código do trigger 1</figcaption>\n",
    "\n",
    "![Trigger1 Resultado](triggers_mongo/trigger1_resultado.jpg)\n",
    "<figcaption>Figura 3- Resultado da utilização do trigger 1</figcaption>\n",
    "\n",
    "O trigger 2 corresponde a uma função que foi projetada para ser utilizada para monitorizar inserções ou atualizações na coleção de \"Appointments\". Quando uma consulta é marcada, a função calcula o número de dias restantes até ao dia da consulta e envia um e-mail de notificação ao paciente correspondente, utilizando a API de e-mail do SendGrid, com o intuito de relembrar o paciente da consulta que se avizinha.\n",
    "\n",
    "![Trigger2](triggers_mongo/trigger2.jpg)\n",
    "<figcaption>Figura 4- Código do trigger 2</figcaption>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Queries MongoDB\n",
    "Com o intuito de demonstrar a operabilidade da bases de dados NOSQL impletanda no mongo desenhou-se um conjunto de consultas que pretendem simular consultas que podem ser realizada durante a atividade diária do hospital, ou para a análise dos dados de operação do hospital"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número total de pacientes: 378\n"
     ]
    }
   ],
   "source": [
    "# número de pacientes registados no hospital\n",
    "def count_patients():\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "    count = db['Patients'].count_documents({})\n",
    "    print(f\"Número total de pacientes: {count}\")\n",
    "    client.close()\n",
    "\n",
    "count_patients()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantidade de pacientes com tipo sanguíneo O+: 36\n",
      "Nome: Amelia Tran, Tipo Sanguíneo: O+\n",
      "Nome: Amelia Tran, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Garcia, Tipo Sanguíneo: O+\n",
      "Nome: Mia Gomez, Tipo Sanguíneo: O+\n",
      "Nome: Emma Flores, Tipo Sanguíneo: O+\n",
      "Nome: Charlotte Ngo, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Nguyen, Tipo Sanguíneo: O+\n",
      "Nome: Natalie Trinh, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Lam, Tipo Sanguíneo: O+\n",
      "Nome: Ava Nguyen, Tipo Sanguíneo: O+\n",
      "Nome: Abigail Vuong, Tipo Sanguíneo: O+\n",
      "Nome: Avery Hoang, Tipo Sanguíneo: O+\n",
      "Nome: Ella Le, Tipo Sanguíneo: O+\n",
      "Nome: Amelia Tran, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Garcia, Tipo Sanguíneo: O+\n",
      "Nome: Mia Gomez, Tipo Sanguíneo: O+\n",
      "Nome: Emma Flores, Tipo Sanguíneo: O+\n",
      "Nome: Charlotte Ngo, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Nguyen, Tipo Sanguíneo: O+\n",
      "Nome: Natalie Trinh, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Lam, Tipo Sanguíneo: O+\n",
      "Nome: Ava Nguyen, Tipo Sanguíneo: O+\n",
      "Nome: Abigail Vuong, Tipo Sanguíneo: O+\n",
      "Nome: Avery Hoang, Tipo Sanguíneo: O+\n",
      "Nome: Ella Le, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Garcia, Tipo Sanguíneo: O+\n",
      "Nome: Mia Gomez, Tipo Sanguíneo: O+\n",
      "Nome: Emma Flores, Tipo Sanguíneo: O+\n",
      "Nome: Charlotte Ngo, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Nguyen, Tipo Sanguíneo: O+\n",
      "Nome: Natalie Trinh, Tipo Sanguíneo: O+\n",
      "Nome: Sophia Lam, Tipo Sanguíneo: O+\n",
      "Nome: Ava Nguyen, Tipo Sanguíneo: O+\n",
      "Nome: Abigail Vuong, Tipo Sanguíneo: O+\n",
      "Nome: Avery Hoang, Tipo Sanguíneo: O+\n",
      "Nome: Ella Le, Tipo Sanguíneo: O+\n"
     ]
    }
   ],
   "source": [
    "# lista de pacientes por grupo sanguíneo\n",
    "def list_patients_by_blood_type(blood_type):\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "\n",
    "    # Contar o número de pacientes com o tipo sanguíneo especificado\n",
    "    count = db['Patients'].count_documents({\"blood_type\": blood_type})\n",
    "    print(f\"Quantidade de pacientes com tipo sanguíneo {blood_type}: {count}\")\n",
    "\n",
    "    # Buscar e listar os pacientes com o tipo sanguíneo especificado\n",
    "    patients = db['Patients'].find({\"blood_type\": blood_type}, {\"_id\": 0, \"patient_fname\": 1, \"patient_lname\": 1, \"blood_type\": 1})\n",
    "    for patient in patients:\n",
    "        print(f\"Nome: {patient['patient_fname']} {patient['patient_lname']}, Tipo Sanguíneo: {patient['blood_type']}\")\n",
    "    \n",
    "    client.close()\n",
    "\n",
    "list_patients_by_blood_type(\"O+\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantidade de pacientes do sexo masculino: 138\n",
      "Quantidade de pacientes do sexo feminino: 132\n",
      "Nome: Amelia Tran, Sexo: Female\n",
      "Nome: Amelia Tran, Sexo: Female\n",
      "Nome: Jane Smith, Sexo: Female\n",
      "Nome: Emily Brown, Sexo: Female\n",
      "Nome: Sophia Garcia, Sexo: Female\n",
      "Nome: Olivia Lee, Sexo: Female\n",
      "Nome: Emma Perez, Sexo: Female\n",
      "Nome: Isabella Hernandez, Sexo: Female\n",
      "Nome: Mia Gomez, Sexo: Female\n",
      "Nome: Ava Rivera, Sexo: Female\n",
      "Nome: Sophia Gonzalez, Sexo: Female\n",
      "Nome: Olivia Perez, Sexo: Female\n",
      "Nome: Emma Flores, Sexo: Female\n",
      "Nome: Olivia Gutierrez, Sexo: Female\n",
      "Nome: Ava Tran, Sexo: Female\n",
      "Nome: Sophia Le, Sexo: Female\n",
      "Nome: Amelia Huynh, Sexo: Female\n",
      "Nome: Isabella Phan, Sexo: Female\n",
      "Nome: Charlotte Ngo, Sexo: Female\n",
      "Nome: Amelia Pham, Sexo: Female\n",
      "Nome: Evelyn Bui, Sexo: Female\n",
      "Nome: Sophia Nguyen, Sexo: Female\n",
      "Nome: Madison Dinh, Sexo: Female\n",
      "Nome: Scarlett Huynh, Sexo: Female\n",
      "Nome: Victoria Lam, Sexo: Female\n",
      "Nome: Natalie Trinh, Sexo: Female\n",
      "Nome: Olivia Nguyen, Sexo: Female\n",
      "Nome: Emma Dinh, Sexo: Female\n",
      "Nome: Isabella Huynh, Sexo: Female\n",
      "Nome: Sophia Lam, Sexo: Female\n",
      "Nome: Charlotte Trinh, Sexo: Female\n",
      "Nome: Ava Nguyen, Sexo: Female\n",
      "Nome: Harper Ho, Sexo: Female\n",
      "Nome: Amelia Le, Sexo: Female\n",
      "Nome: Evelyn Ly, Sexo: Female\n",
      "Nome: Abigail Vuong, Sexo: Female\n",
      "Nome: Olivia Tran, Sexo: Female\n",
      "Nome: Emma Luu, Sexo: Female\n",
      "Nome: Avery Hoang, Sexo: Female\n",
      "Nome: Sophia Phan, Sexo: Female\n",
      "Nome: Mia Nguyen, Sexo: Female\n",
      "Nome: Ella Le, Sexo: Female\n",
      "Nome: Sofia Pham, Sexo: Female\n",
      "Nome: Scarlett Dang, Sexo: Female\n",
      "Nome: Madison Nguyen, Sexo: Female\n",
      "Nome: Amelia Tran, Sexo: Female\n",
      "Nome: Jane Smith, Sexo: Female\n",
      "Nome: Emily Brown, Sexo: Female\n",
      "Nome: Sophia Garcia, Sexo: Female\n",
      "Nome: Olivia Lee, Sexo: Female\n",
      "Nome: Emma Perez, Sexo: Female\n",
      "Nome: Isabella Hernandez, Sexo: Female\n",
      "Nome: Mia Gomez, Sexo: Female\n",
      "Nome: Ava Rivera, Sexo: Female\n",
      "Nome: Sophia Gonzalez, Sexo: Female\n",
      "Nome: Olivia Perez, Sexo: Female\n",
      "Nome: Emma Flores, Sexo: Female\n",
      "Nome: Olivia Gutierrez, Sexo: Female\n",
      "Nome: Ava Tran, Sexo: Female\n",
      "Nome: Sophia Le, Sexo: Female\n",
      "Nome: Amelia Huynh, Sexo: Female\n",
      "Nome: Isabella Phan, Sexo: Female\n",
      "Nome: Charlotte Ngo, Sexo: Female\n",
      "Nome: Amelia Pham, Sexo: Female\n",
      "Nome: Evelyn Bui, Sexo: Female\n",
      "Nome: Sophia Nguyen, Sexo: Female\n",
      "Nome: Madison Dinh, Sexo: Female\n",
      "Nome: Scarlett Huynh, Sexo: Female\n",
      "Nome: Victoria Lam, Sexo: Female\n",
      "Nome: Natalie Trinh, Sexo: Female\n",
      "Nome: Olivia Nguyen, Sexo: Female\n",
      "Nome: Emma Dinh, Sexo: Female\n",
      "Nome: Isabella Huynh, Sexo: Female\n",
      "Nome: Sophia Lam, Sexo: Female\n",
      "Nome: Charlotte Trinh, Sexo: Female\n",
      "Nome: Ava Nguyen, Sexo: Female\n",
      "Nome: Harper Ho, Sexo: Female\n",
      "Nome: Amelia Le, Sexo: Female\n",
      "Nome: Evelyn Ly, Sexo: Female\n",
      "Nome: Abigail Vuong, Sexo: Female\n",
      "Nome: Olivia Tran, Sexo: Female\n",
      "Nome: Emma Luu, Sexo: Female\n",
      "Nome: Avery Hoang, Sexo: Female\n",
      "Nome: Sophia Phan, Sexo: Female\n",
      "Nome: Mia Nguyen, Sexo: Female\n",
      "Nome: Ella Le, Sexo: Female\n",
      "Nome: Sofia Pham, Sexo: Female\n",
      "Nome: Scarlett Dang, Sexo: Female\n",
      "Nome: Madison Nguyen, Sexo: Female\n",
      "Nome: Jane Smith, Sexo: Female\n",
      "Nome: Emily Brown, Sexo: Female\n",
      "Nome: Sophia Garcia, Sexo: Female\n",
      "Nome: Olivia Lee, Sexo: Female\n",
      "Nome: Emma Perez, Sexo: Female\n",
      "Nome: Isabella Hernandez, Sexo: Female\n",
      "Nome: Mia Gomez, Sexo: Female\n",
      "Nome: Ava Rivera, Sexo: Female\n",
      "Nome: Sophia Gonzalez, Sexo: Female\n",
      "Nome: Olivia Perez, Sexo: Female\n",
      "Nome: Emma Flores, Sexo: Female\n",
      "Nome: Olivia Gutierrez, Sexo: Female\n",
      "Nome: Ava Tran, Sexo: Female\n",
      "Nome: Sophia Le, Sexo: Female\n",
      "Nome: Amelia Huynh, Sexo: Female\n",
      "Nome: Isabella Phan, Sexo: Female\n",
      "Nome: Charlotte Ngo, Sexo: Female\n",
      "Nome: Amelia Pham, Sexo: Female\n",
      "Nome: Evelyn Bui, Sexo: Female\n",
      "Nome: Sophia Nguyen, Sexo: Female\n",
      "Nome: Madison Dinh, Sexo: Female\n",
      "Nome: Scarlett Huynh, Sexo: Female\n",
      "Nome: Victoria Lam, Sexo: Female\n",
      "Nome: Natalie Trinh, Sexo: Female\n",
      "Nome: Olivia Nguyen, Sexo: Female\n",
      "Nome: Emma Dinh, Sexo: Female\n",
      "Nome: Isabella Huynh, Sexo: Female\n",
      "Nome: Sophia Lam, Sexo: Female\n",
      "Nome: Charlotte Trinh, Sexo: Female\n",
      "Nome: Ava Nguyen, Sexo: Female\n",
      "Nome: Harper Ho, Sexo: Female\n",
      "Nome: Amelia Le, Sexo: Female\n",
      "Nome: Evelyn Ly, Sexo: Female\n",
      "Nome: Abigail Vuong, Sexo: Female\n",
      "Nome: Olivia Tran, Sexo: Female\n",
      "Nome: Emma Luu, Sexo: Female\n",
      "Nome: Avery Hoang, Sexo: Female\n",
      "Nome: Sophia Phan, Sexo: Female\n",
      "Nome: Mia Nguyen, Sexo: Female\n",
      "Nome: Ella Le, Sexo: Female\n",
      "Nome: Sofia Pham, Sexo: Female\n",
      "Nome: Scarlett Dang, Sexo: Female\n",
      "Nome: Madison Nguyen, Sexo: Female\n"
     ]
    }
   ],
   "source": [
    "# pacientes por genero\n",
    "def list_patients_by_gender(gender):\n",
    "    # Mapear a entrada do utilizador para o sexo correspondente\n",
    "    gender_mapping = {\"F\": \"Female\", \"M\": \"Male\"}\n",
    "    gender = gender_mapping.get(gender.upper())\n",
    "    \n",
    "    if not gender:\n",
    "        print(\"Por favor, insira 'F' para female ou 'M' para male.\")\n",
    "        return\n",
    "\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "\n",
    "    # Contar o número de pacientes por sexo\n",
    "    count_male = db['Patients'].count_documents({\"gender\": \"Male\"})\n",
    "    count_female = db['Patients'].count_documents({\"gender\": \"Female\"})\n",
    "    print(f\"Quantidade de pacientes do sexo masculino: {count_male}\")\n",
    "    print(f\"Quantidade de pacientes do sexo feminino: {count_female}\")\n",
    "\n",
    "    # Buscar e listar os pacientes com o sexo especificado\n",
    "    patients = db['Patients'].find({\"gender\": gender}, {\"_id\": 0, \"patient_fname\": 1, \"patient_lname\": 1, \"gender\": 1})\n",
    "    for patient in patients:\n",
    "        print(f\"Nome: {patient['patient_fname']} {patient['patient_lname']}, Sexo: {patient['gender']}\")\n",
    "    \n",
    "    client.close()\n",
    "\n",
    "gender_input = input(\"Insira 'F' para female ou 'M' para male: \")\n",
    "list_patients_by_gender(gender_input)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Doutor: Robert Perez, Número de Appointments: 6\n",
      "Appointments:\n",
      "- Data: 2017-11-08 00:00:00, Hora: 16:47\n",
      "- Data: 2019-10-04 00:00:00, Hora: 13:30\n",
      "- Data: 2023-07-23 00:00:00, Hora: 15:00\n",
      "- Data: 2023-09-02 00:00:00, Hora: 11:30\n",
      "- Data: 2023-12-22 00:00:00, Hora: 16:00\n",
      "- Data: 2023-06-08 00:00:00, Hora: 14:00\n",
      "\n",
      "Doutor: Ellen Wright, Número de Appointments: 2\n",
      "Appointments:\n",
      "- Data: 2020-10-10 00:00:00, Hora: 18:46\n",
      "- Data: 2023-05-04 00:00:00, Hora: 16:50\n",
      "\n",
      "Doutor: James Carpenter, Número de Appointments: 4\n",
      "Appointments:\n",
      "- Data: 2021-07-14 00:00:00, Hora: 16:32\n",
      "- Data: 2020-12-28 00:00:00, Hora: 14:17\n",
      "- Data: 2021-08-11 00:00:00, Hora: 18:40\n",
      "- Data: 2023-02-11 00:00:00, Hora: 17:10\n",
      "\n",
      "Doutor: Noah Terry, Número de Appointments: 5\n",
      "Appointments:\n",
      "- Data: 2023-11-27 00:00:00, Hora: 10:39\n",
      "- Data: 2023-06-27 00:00:00, Hora: 11:31\n",
      "- Data: 2023-10-16 00:00:00, Hora: 19:30\n",
      "- Data: 2023-09-23 00:00:00, Hora: 10:25\n",
      "- Data: 2023-05-19 00:00:00, Hora: 16:50\n",
      "\n",
      "Doutor: Kimberly Blankenship, Número de Appointments: 3\n",
      "Appointments:\n",
      "- Data: 2020-02-10 00:00:00, Hora: 11:49\n",
      "- Data: 2021-05-12 00:00:00, Hora: 16:44\n",
      "- Data: 2023-02-05 00:00:00, Hora: 11:10\n",
      "\n",
      "Doutor: Aaron Turner, Número de Appointments: 2\n",
      "Appointments:\n",
      "- Data: 2021-10-22 00:00:00, Hora: 17:10\n",
      "- Data: 2023-02-04 00:00:00, Hora: 16:50\n",
      "\n",
      "Doutor: Jessica Jones, Número de Appointments: 2\n",
      "Appointments:\n",
      "- Data: 2022-10-28 00:00:00, Hora: 16:15\n",
      "- Data: 2023-10-01 00:00:00, Hora: 11:10\n",
      "\n",
      "Doutor: Lisa Hayes, Número de Appointments: 1\n",
      "Appointments:\n",
      "- Data: 2023-12-27 00:00:00, Hora: 11:15\n",
      "\n",
      "Doutor: Lee Collins, Número de Appointments: 5\n",
      "Appointments:\n",
      "- Data: 2020-12-15 00:00:00, Hora: 19:60\n",
      "- Data: 2023-03-20 00:00:00, Hora: 11:15\n",
      "- Data: 2023-02-22 00:00:00, Hora: 11:15\n",
      "- Data: 2023-09-21 00:00:00, Hora: 14:00\n",
      "- Data: 2023-12-15 00:00:00, Hora: 13:30\n",
      "\n",
      "Doutor: Destiny Nicholson, Número de Appointments: 2\n",
      "Appointments:\n",
      "- Data: 2016-12-26 00:00:00, Hora: 15:34\n",
      "- Data: 2023-10-09 00:00:00, Hora: 17:34\n",
      "\n",
      "Doutor: Emily Rowe, Número de Appointments: 7\n",
      "Appointments:\n",
      "- Data: 2021-10-22 00:00:00, Hora: 8:17\n",
      "- Data: 2019-08-23 00:00:00, Hora: 17:27\n",
      "- Data: 2021-05-23 00:00:00, Hora: 11:45\n",
      "- Data: 2021-10-22 00:00:00, Hora: 10:15\n",
      "- Data: 2020-05-27 00:00:00, Hora: 11:34\n",
      "- Data: 2020-10-20 00:00:00, Hora: 15:27\n",
      "- Data: 2023-10-24 00:00:00, Hora: 17:10\n",
      "\n",
      "Doutor: Dawn Roberts, Número de Appointments: 1\n",
      "Appointments:\n",
      "- Data: 2023-12-01 00:00:00, Hora: 17:57\n",
      "\n",
      "Doutor: Joshua Carter, Número de Appointments: 1\n",
      "Appointments:\n",
      "- Data: 2018-05-20 00:00:00, Hora: 11:60\n",
      "\n",
      "Doutor: Ashley Lucas, Número de Appointments: 6\n",
      "Appointments:\n",
      "- Data: 2017-12-17 00:00:00, Hora: 17:14\n",
      "- Data: 2018-11-15 00:00:00, Hora: 18:25\n",
      "- Data: 2023-05-24 00:00:00, Hora: 11:00\n",
      "- Data: 2023-09-23 00:00:00, Hora: 11:15\n",
      "- Data: 2023-09-13 00:00:00, Hora: 16:00\n",
      "- Data: 2023-08-02 00:00:00, Hora: 13:30\n",
      "\n",
      "Doutor: Daniel Mills, Número de Appointments: 4\n",
      "Appointments:\n",
      "- Data: 2018-11-29 00:00:00, Hora: 10:25\n",
      "- Data: 2018-08-13 00:00:00, Hora: 11:47\n",
      "- Data: 2018-09-11 00:00:00, Hora: 10:45\n",
      "- Data: 2023-04-19 00:00:00, Hora: 17:10\n",
      "\n",
      "Doutor: James Williams, Número de Appointments: 1\n",
      "Appointments:\n",
      "- Data: 2023-05-14 00:00:00, Hora: 10:15\n",
      "\n",
      "Doutor: Jillian Gordon, Número de Appointments: 1\n",
      "Appointments:\n",
      "- Data: 2023-11-29 00:00:00, Hora: 18:11\n",
      "\n",
      "Doutor: William Grant, Número de Appointments: 3\n",
      "Appointments:\n",
      "- Data: 2019-11-14 00:00:00, Hora: 14:36\n",
      "- Data: 2021-10-23 00:00:00, Hora: 16:18\n",
      "- Data: 2023-02-08 00:00:00, Hora: 11:10\n",
      "\n",
      "Doutor: Scott Holmes, Número de Appointments: 3\n",
      "Appointments:\n",
      "- Data: 2023-11-11 00:00:00, Hora: 11:10\n",
      "- Data: 2023-10-28 00:00:00, Hora: 15:57\n",
      "- Data: 2023-06-04 00:00:00, Hora: 17:10\n",
      "\n",
      "Doutor: Sarah Boyd, Número de Appointments: 6\n",
      "Appointments:\n",
      "- Data: 2018-11-27 00:00:00, Hora: 18:11\n",
      "- Data: 2023-10-03 00:00:00, Hora: 11:28\n",
      "- Data: 2023-10-15 00:00:00, Hora: 16:00\n",
      "- Data: 2023-08-25 00:00:00, Hora: 11:30\n",
      "- Data: 2023-06-01 00:00:00, Hora: 16:00\n",
      "- Data: 2023-04-09 00:00:00, Hora: 13:30\n",
      "\n",
      "Doutor: Kendra Russell, Número de Appointments: 2\n",
      "Appointments:\n",
      "- Data: 2015-10-02 00:00:00, Hora: 17:52\n",
      "- Data: 2023-08-16 00:00:00, Hora: 17:34\n",
      "\n",
      "Doutor: Christina Dalton, Número de Appointments: 5\n",
      "Appointments:\n",
      "- Data: 2015-12-05 00:00:00, Hora: 10:48\n",
      "- Data: 2023-11-16 00:00:00, Hora: 11:30\n",
      "- Data: 2023-07-06 00:00:00, Hora: 16:00\n",
      "- Data: 2023-10-24 00:00:00, Hora: 14:00\n",
      "- Data: 2023-03-10 00:00:00, Hora: 17:34\n",
      "\n",
      "Doutor: Christopher Martinez, Número de Appointments: 5\n",
      "Appointments:\n",
      "- Data: 2022-12-20 00:00:00, Hora: 17:34\n",
      "- Data: 2023-02-23 00:00:00, Hora: 11:30\n",
      "- Data: 2023-02-07 00:00:00, Hora: 11:15\n",
      "- Data: 2023-02-04 00:00:00, Hora: 14:00\n",
      "- Data: 2023-07-23 00:00:00, Hora: 13:30\n",
      "\n",
      "Doutor: Michael Peterson, Número de Appointments: 5\n",
      "Appointments:\n",
      "- Data: 2016-12-12 00:00:00, Hora: 14:15\n",
      "- Data: 2023-11-13 00:00:00, Hora: 11:30\n",
      "- Data: 2023-06-01 00:00:00, Hora: 11:15\n",
      "- Data: 2023-07-14 00:00:00, Hora: 14:00\n",
      "- Data: 2023-08-16 00:00:00, Hora: 17:34\n",
      "\n",
      "Doutor: Dillon Jones, Número de Appointments: 2\n",
      "Appointments:\n",
      "- Data: 2018-12-10 00:00:00, Hora: 19:29\n",
      "- Data: 2023-08-12 00:00:00, Hora: 16:50\n",
      "\n",
      "Doutor: Brittany Collins, Número de Appointments: 6\n",
      "Appointments:\n",
      "- Data: 2013-12-21 00:00:00, Hora: 13:13\n",
      "- Data: 2022-10-21 00:00:00, Hora: 14:47\n",
      "- Data: 2023-11-13 00:00:00, Hora: 14:00\n",
      "- Data: 2023-09-24 00:00:00, Hora: 11:30\n",
      "- Data: 2023-09-09 00:00:00, Hora: 16:00\n",
      "- Data: 2023-07-27 00:00:00, Hora: 14:00\n",
      "\n",
      "Doutor: Rebecca Reyes, Número de Appointments: 6\n",
      "Appointments:\n",
      "- Data: 2022-12-12 00:00:00, Hora: 16:50\n",
      "- Data: 2018-12-15 00:00:00, Hora: 16:25\n",
      "- Data: 2023-04-25 00:00:00, Hora: 10:00\n",
      "- Data: 2023-05-15 00:00:00, Hora: 11:30\n",
      "- Data: 2023-01-16 00:00:00, Hora: 16:00\n",
      "- Data: 2023-02-16 00:00:00, Hora: 13:30\n",
      "\n",
      "Doutor: Andrew Deleon, Número de Appointments: 3\n",
      "Appointments:\n",
      "- Data: 2023-11-17 00:00:00, Hora: 17:47\n",
      "- Data: 2019-12-23 00:00:00, Hora: 9:46\n",
      "- Data: 2023-05-11 00:00:00, Hora: 17:10\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# consultas por médico\n",
    "def list_appointments_by_doctor():\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "\n",
    "    # Contar appointments por nome de doutor e exibir a data e o tempo de cada appointment\n",
    "    pipeline = [\n",
    "        {\n",
    "            \"$lookup\": {\n",
    "                \"from\": \"Staff\",\n",
    "                \"localField\": \"iddoctor\",\n",
    "                \"foreignField\": \"_id\",\n",
    "                \"as\": \"doctor_info\"\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$unwind\": \"$doctor_info\"\n",
    "        },\n",
    "        {\n",
    "            \"$group\": {\n",
    "                \"_id\": {\n",
    "                    \"doctor_firstName\": \"$doctor_info.firstName\",\n",
    "                    \"doctor_lastName\": \"$doctor_info.lastName\"\n",
    "                },\n",
    "                \"appointments\": {\n",
    "                    \"$push\": {\n",
    "                        \"appointment_date\": \"$appointment_date\",\n",
    "                        \"appointment_time\": \"$appointment_time\"\n",
    "                    }\n",
    "                },\n",
    "                \"appointments_count\": {\"$sum\": 1}\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "    appointments_by_doctor = list(db['Appointments'].aggregate(pipeline))\n",
    "    \n",
    "    # Exibir o resultado\n",
    "    for result in appointments_by_doctor:\n",
    "        doctor_name = result['_id']['doctor_firstName'] + \" \" + result['_id']['doctor_lastName']\n",
    "        print(f\"Doutor: {doctor_name}, Número de Appointments: {result['appointments_count']}\")\n",
    "        print(\"Appointments:\")\n",
    "        for appointment in result['appointments']:\n",
    "            print(f\"- Data: {appointment['appointment_date']}, Hora: {appointment['appointment_time']}\")\n",
    "        print()\n",
    "    \n",
    "    client.close()\n",
    "\n",
    "list_appointments_by_doctor()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Médico: Christopher Martinez, Número de Consultas: 4\n",
      "Médico: Aaron Turner, Número de Consultas: 1\n",
      "Médico: Brittany Collins, Número de Consultas: 4\n",
      "Médico: James Carpenter, Número de Consultas: 1\n",
      "Médico: Michael Peterson, Número de Consultas: 4\n",
      "Médico: Noah Terry, Número de Consultas: 5\n",
      "Médico: Daniel Mills, Número de Consultas: 1\n",
      "Médico: Emily Rowe, Número de Consultas: 1\n",
      "Médico: William Grant, Número de Consultas: 1\n",
      "Médico: Robert Perez, Número de Consultas: 4\n",
      "Médico: Sarah Boyd, Número de Consultas: 5\n",
      "Médico: Christina Dalton, Número de Consultas: 4\n",
      "Médico: Kimberly Blankenship, Número de Consultas: 1\n",
      "Médico: Lisa Hayes, Número de Consultas: 1\n",
      "Médico: Jessica Jones, Número de Consultas: 1\n",
      "Médico: Jillian Gordon, Número de Consultas: 1\n",
      "Médico: James Williams, Número de Consultas: 1\n",
      "Médico: Kendra Russell, Número de Consultas: 1\n",
      "Médico: Lee Collins, Número de Consultas: 4\n",
      "Médico: Ashley Lucas, Número de Consultas: 4\n",
      "Médico: Dillon Jones, Número de Consultas: 1\n",
      "Médico: Dawn Roberts, Número de Consultas: 1\n",
      "Médico: Andrew Deleon, Número de Consultas: 2\n",
      "Médico: Rebecca Reyes, Número de Consultas: 4\n",
      "Médico: Scott Holmes, Número de Consultas: 3\n",
      "Médico: Destiny Nicholson, Número de Consultas: 1\n",
      "Médico: Ellen Wright, Número de Consultas: 1\n"
     ]
    }
   ],
   "source": [
    "# número de consultas de cada médico num determinado ano\n",
    "def list_appointments_by_date(year):\n",
    "    client = MongoClient('mongodb://localhost:27017/')\n",
    "    db = client['Hospital']\n",
    "\n",
    "    # Contar as consultas por médico para o ano especificado\n",
    "    pipeline = [\n",
    "        {\n",
    "            \"$match\": {\"$expr\": {\"$eq\": [{\"$year\": \"$appointment_date\"}, year]}}\n",
    "        },\n",
    "        {\n",
    "            \"$group\": {\n",
    "                \"_id\": \"$iddoctor\",\n",
    "                \"appointments_count\": {\"$sum\": 1}\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$lookup\": {\n",
    "                \"from\": \"Staff\",\n",
    "                \"localField\": \"_id\",\n",
    "                \"foreignField\": \"_id\",\n",
    "                \"as\": \"doctor_info\"\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$unwind\": \"$doctor_info\"\n",
    "        },\n",
    "        {\n",
    "            \"$project\": {\n",
    "                \"doctor_name\": {\"$concat\": [\"$doctor_info.firstName\", \" \", \"$doctor_info.lastName\"]},\n",
    "                \"appointments_count\": 1\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "    appointments_by_doctor = list(db['Appointments'].aggregate(pipeline))\n",
    "\n",
    "    # Exibir o resultado\n",
    "    for result in appointments_by_doctor:\n",
    "        print(f\"Médico: {result['doctor_name']}, Número de Consultas: {result['appointments_count']}\")\n",
    "    \n",
    "    client.close()\n",
    "\n",
    "year = input(\"Insira o ano para obter o número de consultas por médico: \")\n",
    "list_appointments_by_date(int(year))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neo4j\n",
    "\n",
    "<p align=\"justify\">\n",
    "A Neo4j, é uma plataforma de banco de dados orientada a grafos, projetada para modelar, armazenar e consultar dados que têm uma forte componente relacional. Diferente dss bases de dados relacionais tradicionais, que utilizam tabelas para armazenar dados, o Neo4j usa uma estrutura baseada em grafos composta por nós (que representam entidades) e relações (que conectam essas entidades), permitindo uma representação mais natural e eficiente de redes complexas. Cada nó e relacionamento pode ter propriedades adicionais, como pares de chave-valor, proporcionando uma grande flexibilidade na modelagem de dados. A consulta no Neo4j é realizada através de uma linguagem de consulta específica chamada Cypher, que é intuitiva e poderosa, permitindo explorar padrões de relacionamentos de maneira eficiente. Devido à sua capacidade de lidar com grandes volumes de dados interconectados, o Neo4j é amplamente utilizado em diversas áreas, como análise de redes sociais, recomendações de produtos, detecção de fraudes e gerenciamento de redes de conhecimento. A sua arquitetura permite consultas rápidas e desempenho escalável, tornando-o uma escolha popular para aplicações que requerem uma exploração profunda e em tempo real das interconexões entre dados.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passagem dos dados para o Neo4j\n",
    "\n",
    "### Adição da informação associada aos pacientes\n",
    "<p align=\"justify\">\n",
    "O seguinte código realiza duas operações principais, a extração de dados de um banco de dados Oracle e a inserção desses dados na plantaforma Neo4j. Este código foi desenvolvido para proceder à passagem de toda a informação relativa aos pacientes para uma base de dados orientadas a grafos em que as entradas de cada table vai dão origem a 4 nodos, com os atributos que correspondem às colunas no modelo relacional\n",
    "\n",
    "Entidades envolvidas: \n",
    "* HOSPITAL_PATIENT\n",
    "* HOSPITAL_INSURANCE\n",
    "* HOSPITAL_MEDICAL_HISTORY\n",
    "* HOSPITAL_EMERGENCY_CONTACT\n",
    "\n",
    "<p align=\"justify\">\n",
    "Na primeira operação, definiu-se a função extract_data_from_oracle, que começa por realizar a conexão à base de dados relacional e posteriormente são realizadas quatro consultas independentes para extrair a informação das entidades envolvidas. Na segunda operação, definiu-se a função insert_data_to_neo4j que é responsável por inserir os dados extraídos do Oracle no banco de dados Neo4j. Esta função interage com o Neo4j através da biblioteca py2neo, com o endereço e as credenciais fornecidas, cria nós do tipo \"Patient\", \"Insurance\", \"MedicalHistory\"e \"EmergencyContact\" e insere cada registro extraído do Oracle, no Neo4j. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extraindo dados do Oracle...\n",
      "Pacientes extraídos: 270\n",
      "Seguros extraídos: 10\n",
      "Históricos médicos extraídos: 78\n",
      "Contatos de emergência extraídos: 20\n",
      "Inserindo dados no Neo4J...\n",
      "Paciente inserido: Amelia Tran\n",
      "Paciente inserido: Michael Do\n",
      "Paciente inserido: Jacob Lam\n",
      "Paciente inserido: Amelia Tran\n",
      "Paciente inserido: Michael Do\n",
      "Paciente inserido: John Doe\n",
      "Paciente inserido: Jane Smith\n",
      "Paciente inserido: Michael Johnson\n",
      "Paciente inserido: Emily Brown\n",
      "Paciente inserido: William Martinez\n",
      "Paciente inserido: Sophia Garcia\n",
      "Paciente inserido: James Lopez\n",
      "Paciente inserido: Olivia Lee\n",
      "Paciente inserido: Benjamin Gonzalez\n",
      "Paciente inserido: Emma Perez\n",
      "Paciente inserido: Jacob Rodriguez\n",
      "Paciente inserido: Isabella Hernandez\n",
      "Paciente inserido: Ethan Lopez\n",
      "Paciente inserido: Mia Gomez\n",
      "Paciente inserido: Alexander Diaz\n",
      "Paciente inserido: Ava Rivera\n",
      "Paciente inserido: William Smith\n",
      "Paciente inserido: Sophia Gonzalez\n",
      "Paciente inserido: Michael Martinez\n",
      "Paciente inserido: Olivia Perez\n",
      "Paciente inserido: Liam Torres\n",
      "Paciente inserido: Emma Flores\n",
      "Paciente inserido: Noah Ramirez\n",
      "Paciente inserido: Olivia Gutierrez\n",
      "Paciente inserido: William Nguyen\n",
      "Paciente inserido: Ava Tran\n",
      "Paciente inserido: James Kim\n",
      "Paciente inserido: Sophia Le\n",
      "Paciente inserido: Logan Do\n",
      "Paciente inserido: Amelia Huynh\n",
      "Paciente inserido: Ethan Vo\n",
      "Paciente inserido: Isabella Phan\n",
      "Paciente inserido: Mason Duong\n",
      "Paciente inserido: Oliver Truong\n",
      "Paciente inserido: Charlotte Ngo\n",
      "Paciente inserido: Lucas Vuong\n",
      "Paciente inserido: Amelia Pham\n",
      "Paciente inserido: Benjamin Le\n",
      "Paciente inserido: Evelyn Bui\n",
      "Paciente inserido: Alexander Ho\n",
      "Paciente inserido: Sophia Nguyen\n",
      "Paciente inserido: Jackson Tran\n",
      "Paciente inserido: Madison Dinh\n",
      "Paciente inserido: Aiden Vo\n",
      "Paciente inserido: Scarlett Huynh\n",
      "Paciente inserido: Daniel Do\n",
      "Paciente inserido: Victoria Lam\n",
      "Paciente inserido: Joseph Mai\n",
      "Paciente inserido: Natalie Trinh\n",
      "Paciente inserido: Samuel Vo\n",
      "Paciente inserido: Olivia Nguyen\n",
      "Paciente inserido: Ethan Tran\n",
      "Paciente inserido: Emma Dinh\n",
      "Paciente inserido: Noah Vo\n",
      "Paciente inserido: Isabella Huynh\n",
      "Paciente inserido: William Do\n",
      "Paciente inserido: Sophia Lam\n",
      "Paciente inserido: James Mai\n",
      "Paciente inserido: Charlotte Trinh\n",
      "Paciente inserido: Logan Vo\n",
      "Paciente inserido: Ava Nguyen\n",
      "Paciente inserido: Mason Pham\n",
      "Paciente inserido: Harper Ho\n",
      "Paciente inserido: Elijah Truong\n",
      "Paciente inserido: Amelia Le\n",
      "Paciente inserido: Benjamin Ngo\n",
      "Paciente inserido: Evelyn Ly\n",
      "Paciente inserido: Alexander Dang\n",
      "Paciente inserido: Abigail Vuong\n",
      "Paciente inserido: Michael Duong\n",
      "Paciente inserido: Olivia Tran\n",
      "Paciente inserido: James Vo\n",
      "Paciente inserido: Emma Luu\n",
      "Paciente inserido: Lucas Ha\n",
      "Paciente inserido: Avery Hoang\n",
      "Paciente inserido: William Bui\n",
      "Paciente inserido: Sophia Phan\n",
      "Paciente inserido: Logan Trinh\n",
      "Paciente inserido: Mia Nguyen\n",
      "Paciente inserido: Benjamin Vu\n",
      "Paciente inserido: Ella Le\n",
      "Paciente inserido: Alexander Ho\n",
      "Paciente inserido: Sofia Pham\n",
      "Paciente inserido: Henry Tran\n",
      "Paciente inserido: Scarlett Dang\n",
      "Paciente inserido: Ethan Duong\n",
      "Paciente inserido: Madison Nguyen\n",
      "Paciente inserido: Jacob Lam\n",
      "Paciente inserido: Amelia Tran\n",
      "Paciente inserido: Michael Do\n",
      "Paciente inserido: John Doe\n",
      "Paciente inserido: Jane Smith\n",
      "Paciente inserido: Michael Johnson\n",
      "Paciente inserido: Emily Brown\n",
      "Paciente inserido: William Martinez\n",
      "Paciente inserido: Sophia Garcia\n",
      "Paciente inserido: James Lopez\n",
      "Paciente inserido: Olivia Lee\n",
      "Paciente inserido: Benjamin Gonzalez\n",
      "Paciente inserido: Emma Perez\n",
      "Paciente inserido: Jacob Rodriguez\n",
      "Paciente inserido: Isabella Hernandez\n",
      "Paciente inserido: Ethan Lopez\n",
      "Paciente inserido: Mia Gomez\n",
      "Paciente inserido: Alexander Diaz\n",
      "Paciente inserido: Ava Rivera\n",
      "Paciente inserido: William Smith\n",
      "Paciente inserido: Sophia Gonzalez\n",
      "Paciente inserido: Michael Martinez\n",
      "Paciente inserido: Olivia Perez\n",
      "Paciente inserido: Liam Torres\n",
      "Paciente inserido: Emma Flores\n",
      "Paciente inserido: Noah Ramirez\n",
      "Paciente inserido: Olivia Gutierrez\n",
      "Paciente inserido: William Nguyen\n",
      "Paciente inserido: Ava Tran\n",
      "Paciente inserido: James Kim\n",
      "Paciente inserido: Sophia Le\n",
      "Paciente inserido: Logan Do\n",
      "Paciente inserido: Amelia Huynh\n",
      "Paciente inserido: Ethan Vo\n",
      "Paciente inserido: Isabella Phan\n",
      "Paciente inserido: Mason Duong\n",
      "Paciente inserido: Oliver Truong\n",
      "Paciente inserido: Charlotte Ngo\n",
      "Paciente inserido: Lucas Vuong\n",
      "Paciente inserido: Amelia Pham\n",
      "Paciente inserido: Benjamin Le\n",
      "Paciente inserido: Evelyn Bui\n",
      "Paciente inserido: Alexander Ho\n",
      "Paciente inserido: Sophia Nguyen\n",
      "Paciente inserido: Jackson Tran\n",
      "Paciente inserido: Madison Dinh\n",
      "Paciente inserido: Aiden Vo\n",
      "Paciente inserido: Scarlett Huynh\n",
      "Paciente inserido: Daniel Do\n",
      "Paciente inserido: Victoria Lam\n",
      "Paciente inserido: Joseph Mai\n",
      "Paciente inserido: Natalie Trinh\n",
      "Paciente inserido: Samuel Vo\n",
      "Paciente inserido: Olivia Nguyen\n",
      "Paciente inserido: Ethan Tran\n",
      "Paciente inserido: Emma Dinh\n",
      "Paciente inserido: Noah Vo\n",
      "Paciente inserido: Isabella Huynh\n",
      "Paciente inserido: William Do\n",
      "Paciente inserido: Sophia Lam\n",
      "Paciente inserido: James Mai\n",
      "Paciente inserido: Charlotte Trinh\n",
      "Paciente inserido: Logan Vo\n",
      "Paciente inserido: Ava Nguyen\n",
      "Paciente inserido: Mason Pham\n",
      "Paciente inserido: Harper Ho\n",
      "Paciente inserido: Elijah Truong\n",
      "Paciente inserido: Amelia Le\n",
      "Paciente inserido: Benjamin Ngo\n",
      "Paciente inserido: Evelyn Ly\n",
      "Paciente inserido: Alexander Dang\n",
      "Paciente inserido: Abigail Vuong\n",
      "Paciente inserido: Michael Duong\n",
      "Paciente inserido: Olivia Tran\n",
      "Paciente inserido: James Vo\n",
      "Paciente inserido: Emma Luu\n",
      "Paciente inserido: Lucas Ha\n",
      "Paciente inserido: Avery Hoang\n",
      "Paciente inserido: William Bui\n",
      "Paciente inserido: Sophia Phan\n",
      "Paciente inserido: Logan Trinh\n",
      "Paciente inserido: Mia Nguyen\n",
      "Paciente inserido: Benjamin Vu\n",
      "Paciente inserido: Ella Le\n",
      "Paciente inserido: Alexander Ho\n",
      "Paciente inserido: Sofia Pham\n",
      "Paciente inserido: Henry Tran\n",
      "Paciente inserido: Scarlett Dang\n",
      "Paciente inserido: Ethan Duong\n",
      "Paciente inserido: Madison Nguyen\n",
      "Paciente inserido: John Doe\n",
      "Paciente inserido: Jane Smith\n",
      "Paciente inserido: Michael Johnson\n",
      "Paciente inserido: Emily Brown\n",
      "Paciente inserido: William Martinez\n",
      "Paciente inserido: Sophia Garcia\n",
      "Paciente inserido: James Lopez\n",
      "Paciente inserido: Olivia Lee\n",
      "Paciente inserido: Benjamin Gonzalez\n",
      "Paciente inserido: Emma Perez\n",
      "Paciente inserido: Jacob Rodriguez\n",
      "Paciente inserido: Isabella Hernandez\n",
      "Paciente inserido: Ethan Lopez\n",
      "Paciente inserido: Mia Gomez\n",
      "Paciente inserido: Alexander Diaz\n",
      "Paciente inserido: Ava Rivera\n",
      "Paciente inserido: William Smith\n",
      "Paciente inserido: Sophia Gonzalez\n",
      "Paciente inserido: Michael Martinez\n",
      "Paciente inserido: Olivia Perez\n",
      "Paciente inserido: Liam Torres\n",
      "Paciente inserido: Emma Flores\n",
      "Paciente inserido: Noah Ramirez\n",
      "Paciente inserido: Olivia Gutierrez\n",
      "Paciente inserido: William Nguyen\n",
      "Paciente inserido: Ava Tran\n",
      "Paciente inserido: James Kim\n",
      "Paciente inserido: Sophia Le\n",
      "Paciente inserido: Logan Do\n",
      "Paciente inserido: Amelia Huynh\n",
      "Paciente inserido: Ethan Vo\n",
      "Paciente inserido: Isabella Phan\n",
      "Paciente inserido: Mason Duong\n",
      "Paciente inserido: Oliver Truong\n",
      "Paciente inserido: Charlotte Ngo\n",
      "Paciente inserido: Lucas Vuong\n",
      "Paciente inserido: Amelia Pham\n",
      "Paciente inserido: Benjamin Le\n",
      "Paciente inserido: Evelyn Bui\n",
      "Paciente inserido: Alexander Ho\n",
      "Paciente inserido: Sophia Nguyen\n",
      "Paciente inserido: Jackson Tran\n",
      "Paciente inserido: Madison Dinh\n",
      "Paciente inserido: Aiden Vo\n",
      "Paciente inserido: Scarlett Huynh\n",
      "Paciente inserido: Daniel Do\n",
      "Paciente inserido: Victoria Lam\n",
      "Paciente inserido: Joseph Mai\n",
      "Paciente inserido: Natalie Trinh\n",
      "Paciente inserido: Samuel Vo\n",
      "Paciente inserido: Olivia Nguyen\n",
      "Paciente inserido: Ethan Tran\n",
      "Paciente inserido: Emma Dinh\n",
      "Paciente inserido: Noah Vo\n",
      "Paciente inserido: Isabella Huynh\n",
      "Paciente inserido: William Do\n",
      "Paciente inserido: Sophia Lam\n",
      "Paciente inserido: James Mai\n",
      "Paciente inserido: Charlotte Trinh\n",
      "Paciente inserido: Logan Vo\n",
      "Paciente inserido: Ava Nguyen\n",
      "Paciente inserido: Mason Pham\n",
      "Paciente inserido: Harper Ho\n",
      "Paciente inserido: Elijah Truong\n",
      "Paciente inserido: Amelia Le\n",
      "Paciente inserido: Benjamin Ngo\n",
      "Paciente inserido: Evelyn Ly\n",
      "Paciente inserido: Alexander Dang\n",
      "Paciente inserido: Abigail Vuong\n",
      "Paciente inserido: Michael Duong\n",
      "Paciente inserido: Olivia Tran\n",
      "Paciente inserido: James Vo\n",
      "Paciente inserido: Emma Luu\n",
      "Paciente inserido: Lucas Ha\n",
      "Paciente inserido: Avery Hoang\n",
      "Paciente inserido: William Bui\n",
      "Paciente inserido: Sophia Phan\n",
      "Paciente inserido: Logan Trinh\n",
      "Paciente inserido: Mia Nguyen\n",
      "Paciente inserido: Benjamin Vu\n",
      "Paciente inserido: Ella Le\n",
      "Paciente inserido: Alexander Ho\n",
      "Paciente inserido: Sofia Pham\n",
      "Paciente inserido: Henry Tran\n",
      "Paciente inserido: Scarlett Dang\n",
      "Paciente inserido: Ethan Duong\n",
      "Paciente inserido: Madison Nguyen\n",
      "Paciente inserido: Jacob Lam\n",
      "Seguro inserido: ABC Insurance\n",
      "Seguro inserido: XYZ Insurance\n",
      "Seguro inserido: DEF Insurance\n",
      "Seguro inserido: GHI Insurance\n",
      "Seguro inserido: JKL Insurance\n",
      "Seguro inserido: MNO Insurance\n",
      "Seguro inserido: PQR Insurance\n",
      "Seguro inserido: STU Insurance\n",
      "Seguro inserido: VWX Insurance\n",
      "Seguro inserido: YZA Insurance\n",
      "Histórico médico inserido: 27\n",
      "Histórico médico inserido: 28\n",
      "Histórico médico inserido: 29\n",
      "Histórico médico inserido: 30\n",
      "Histórico médico inserido: 31\n",
      "Histórico médico inserido: 32\n",
      "Histórico médico inserido: 33\n",
      "Histórico médico inserido: 34\n",
      "Histórico médico inserido: 35\n",
      "Histórico médico inserido: 36\n",
      "Histórico médico inserido: 37\n",
      "Histórico médico inserido: 38\n",
      "Histórico médico inserido: 39\n",
      "Histórico médico inserido: 40\n",
      "Histórico médico inserido: 41\n",
      "Histórico médico inserido: 42\n",
      "Histórico médico inserido: 43\n",
      "Histórico médico inserido: 44\n",
      "Histórico médico inserido: 45\n",
      "Histórico médico inserido: 46\n",
      "Histórico médico inserido: 47\n",
      "Histórico médico inserido: 48\n",
      "Histórico médico inserido: 49\n",
      "Histórico médico inserido: 50\n",
      "Histórico médico inserido: 51\n",
      "Histórico médico inserido: 52\n",
      "Histórico médico inserido: 53\n",
      "Histórico médico inserido: 54\n",
      "Histórico médico inserido: 55\n",
      "Histórico médico inserido: 56\n",
      "Histórico médico inserido: 57\n",
      "Histórico médico inserido: 58\n",
      "Histórico médico inserido: 59\n",
      "Histórico médico inserido: 60\n",
      "Histórico médico inserido: 61\n",
      "Histórico médico inserido: 62\n",
      "Histórico médico inserido: 63\n",
      "Histórico médico inserido: 64\n",
      "Histórico médico inserido: 65\n",
      "Histórico médico inserido: 66\n",
      "Histórico médico inserido: 67\n",
      "Histórico médico inserido: 68\n",
      "Histórico médico inserido: 69\n",
      "Histórico médico inserido: 70\n",
      "Histórico médico inserido: 71\n",
      "Histórico médico inserido: 72\n",
      "Histórico médico inserido: 73\n",
      "Histórico médico inserido: 74\n",
      "Histórico médico inserido: 75\n",
      "Histórico médico inserido: 76\n",
      "Histórico médico inserido: 77\n",
      "Histórico médico inserido: 78\n",
      "Histórico médico inserido: 1\n",
      "Histórico médico inserido: 2\n",
      "Histórico médico inserido: 3\n",
      "Histórico médico inserido: 4\n",
      "Histórico médico inserido: 5\n",
      "Histórico médico inserido: 6\n",
      "Histórico médico inserido: 7\n",
      "Histórico médico inserido: 8\n",
      "Histórico médico inserido: 9\n",
      "Histórico médico inserido: 10\n",
      "Histórico médico inserido: 11\n",
      "Histórico médico inserido: 12\n",
      "Histórico médico inserido: 13\n",
      "Histórico médico inserido: 14\n",
      "Histórico médico inserido: 15\n",
      "Histórico médico inserido: 16\n",
      "Histórico médico inserido: 17\n",
      "Histórico médico inserido: 18\n",
      "Histórico médico inserido: 19\n",
      "Histórico médico inserido: 20\n",
      "Histórico médico inserido: 21\n",
      "Histórico médico inserido: 22\n",
      "Histórico médico inserido: 23\n",
      "Histórico médico inserido: 24\n",
      "Histórico médico inserido: 25\n",
      "Histórico médico inserido: 26\n",
      "Contato de emergência inserido: Emma Thompson\n",
      "Contato de emergência inserido: John Doe\n",
      "Contato de emergência inserido: Jane Smith\n",
      "Contato de emergência inserido: Alice Johnson\n",
      "Contato de emergência inserido: Bob Brown\n",
      "Contato de emergência inserido: Sarah Wilson\n",
      "Contato de emergência inserido: Michael Clark\n",
      "Contato de emergência inserido: Emily White\n",
      "Contato de emergência inserido: David Lee\n",
      "Contato de emergência inserido: Jennifer Martinez\n",
      "Contato de emergência inserido: Daniel Harris\n",
      "Contato de emergência inserido: Matthew Evans\n",
      "Contato de emergência inserido: Olivia Rodriguez\n",
      "Contato de emergência inserido: James Wilson\n",
      "Contato de emergência inserido: Ava Anderson\n",
      "Contato de emergência inserido: Logan Taylor\n",
      "Contato de emergência inserido: Sophia Scott\n",
      "Contato de emergência inserido: Ethan Lewis\n",
      "Contato de emergência inserido: Mia Martinez\n",
      "Contato de emergência inserido: Noah Harris\n"
     ]
    }
   ],
   "source": [
    "def extract_data_from_oracle():\n",
    "    print(\"Extração dos dados do Oracle...\")\n",
    "\n",
    "    # Conexão ao Oracle\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_PATIENT\n",
    "    sql_patient = \"\"\"\n",
    "        SELECT \n",
    "            idpatient,     \n",
    "            patient_fname, \n",
    "            patient_lname, \n",
    "            blood_type, \n",
    "            phone,         \n",
    "            email,         \n",
    "            gender,        \n",
    "            policy_number, \n",
    "            BIRTHDAY\n",
    "        FROM\n",
    "            patient\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_patient)\n",
    "    patients = cursor.fetchall()\n",
    "    print(f\"Pacientes extraídos: {len(patients)}\")\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_INSURANCE\n",
    "    sql_insurance = \"\"\"\n",
    "        SELECT \n",
    "            policy_number,  \n",
    "            provider,       \n",
    "            insurance_plan, \n",
    "            co_pay,         \n",
    "            coverage,       \n",
    "            maternity,      \n",
    "            dental,         \n",
    "            optical     \n",
    "        FROM \n",
    "            insurance\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_insurance)\n",
    "    insurances = cursor.fetchall()\n",
    "    print(f\"Seguros extraídos: {len(insurances)}\")\n",
    "    \n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_MEDICAL_HISTORY\n",
    "    sql_MEDICAL_HISTORY = \"\"\"\n",
    "        SELECT \n",
    "            record_id,   \n",
    "            record_date, \n",
    "            idpatient   \n",
    "        FROM \n",
    "            MEDICAL_HISTORY\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_MEDICAL_HISTORY)\n",
    "    medical_histories = cursor.fetchall()\n",
    "    print(f\"Históricos médicos extraídos: {len(medical_histories)}\")\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_EMERGENCY_CONTACT\n",
    "    sql_emergency_contact = \"\"\"\n",
    "        SELECT \n",
    "            contact_name, \n",
    "            phone,        \n",
    "            relation,    \n",
    "            idpatient  \n",
    "        FROM \n",
    "            emergency_contact\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_emergency_contact)\n",
    "    emergency_contacts = cursor.fetchall()\n",
    "    print(f\"Contatos de emergência extraídos: {len(emergency_contacts)}\")\n",
    "\n",
    "    # Encerramento da conexão\n",
    "    cursor.close(); connection.close()\n",
    "\n",
    "    return patients, insurances, medical_histories, emergency_contacts\n",
    "\n",
    "def insert_data_to_neo4j(patients, insurances, medical_histories, emergency_contacts):\n",
    "    print(\"Inserção dos dados no Neo4J...\")\n",
    "\n",
    "    graph = Graph(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))  # Substitua \"your_password\" pela senha do seu Neo4j\n",
    "\n",
    "    # Inserir pacientes\n",
    "    for patient in patients:\n",
    "        patient_node = Node(\"Patient\", idpatient=patient[0], patient_fname=patient[1], patient_lname=patient[2], \n",
    "                            blood_type=patient[3], phone=patient[4], email=patient[5], gender=patient[6], \n",
    "                            policy_number=patient[7], birthday=patient[8])\n",
    "        graph.create(patient_node)\n",
    "        print(f\"Paciente inserido: {patient[1]} {patient[2]}\")\n",
    "\n",
    "    # Inserir seguros\n",
    "    for insurance in insurances:\n",
    "        insurance_node = Node(\"Insurance\", policy_number=insurance[0], provider=insurance[1], insurance_plan=insurance[2], \n",
    "                              co_pay=insurance[3], coverage=insurance[4], maternity=insurance[5], dental=insurance[6], \n",
    "                              optical=insurance[7])\n",
    "        graph.create(insurance_node)\n",
    "        graph.run(\"MATCH (p:Patient {policy_number: $policy_number}), (i:Insurance {policy_number: $policy_number}) \"\n",
    "                  \"CREATE (p)-[:HAS_INSURANCE]->(i)\", policy_number=insurance[0])\n",
    "        print(f\"Seguro inserido: {insurance[1]}\")\n",
    "\n",
    "    # Inserir históricos médicos\n",
    "    for medical_history in medical_histories:\n",
    "        medical_history_node = Node(\"MedicalHistory\", record_id=medical_history[0], record_date=medical_history[1])\n",
    "        graph.create(medical_history_node)\n",
    "        graph.run(\"MATCH (p:Patient {idpatient: $idpatient}), (m:MedicalHistory {record_id: $record_id}) \"\n",
    "                  \"CREATE (p)-[:HAS_MEDICAL_HISTORY]->(m)\", idpatient=medical_history[2], record_id=medical_history[0])\n",
    "        print(f\"Histórico médico inserido: {medical_history[0]}\")\n",
    "\n",
    "    # Inserir contatos de emergência\n",
    "    for emergency_contact in emergency_contacts:\n",
    "        emergency_contact_node = Node(\"EmergencyContact\", contact_name=emergency_contact[0], phone=emergency_contact[1], \n",
    "                                      relation=emergency_contact[2])\n",
    "        graph.create(emergency_contact_node)\n",
    "        graph.run(\"MATCH (p:Patient {idpatient: $idpatient}), (e:EmergencyContact {contact_name: $contact_name}) \"\n",
    "                  \"CREATE (p)-[:HAS_EMERGENCY_CONTACT]->(e)\", idpatient=emergency_contact[3], contact_name=emergency_contact[0])\n",
    "        print(f\"Contato de emergência inserido: {emergency_contact[0]}\")\n",
    "\n",
    "# Extrair dados do Oracle e inseri-los no Neo4J\n",
    "patients, insurances, medical_histories, emergency_contacts = extract_data_from_oracle()\n",
    "insert_data_to_neo4j(patients, insurances, medical_histories, emergency_contacts)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adição do idepisode\n",
    "\n",
    "<p align=\"justify\">\n",
    "A seginte função \"insert_data_to_neo4j_episodes\" insere dados de episódios extraídos do Oracle no banco de dados Neo4j, criando nós para os episódios e relacionando-os aos pacientes, para isto ela utiliza o comando MERGE para garantir que o nó do episódio seja criado se não existir, ou atualizado se já existir, define a propriedade patient_idpatient para o nó do episódio, posteriormente utiliza o comando MATCH para encontrar o paciente e o episódio no banco de dados e cria um relacionamento HAS_EPISODE entre o paciente e o episódio usando o comando MERGE.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_data_to_neo4j_episodes(episodes):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        for episode in episodes:\n",
    "            # Extrair os dados do episódio\n",
    "            idepisode = episode[0]\n",
    "            patient_idpatient = episode[1]\n",
    "\n",
    "            # Criar nó do episódio\n",
    "            session.run(\"\"\"\n",
    "                MERGE (e:Episode {idepisode: $idepisode})\n",
    "                SET e.patient_idpatient = $patient_idpatient\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode,\n",
    "                \"patient_idpatient\": patient_idpatient\n",
    "            })\n",
    "\n",
    "            # Associar episódio ao paciente\n",
    "            session.run(\"\"\"\n",
    "                MATCH (p:Patient {idpatient: $idpatient})\n",
    "                MATCH (e:Episode {idepisode: $idepisode})\n",
    "                MERGE (p)-[:HAS_EPISODE]->(e)\n",
    "            \"\"\", {\n",
    "                \"idpatient\": patient_idpatient,\n",
    "                \"idepisode\": idepisode\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "\n",
    "\n",
    "def extract_data_from_oracle_episodes():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_EPISODE\n",
    "    sql_episode = \"\"\"\n",
    "        SELECT \n",
    "            idepisode,\n",
    "            patient_idpatient\n",
    "        FROM \n",
    "            episode\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_episode)\n",
    "    episodes = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_episodes(episodes)\n",
    "\n",
    "# Chamar as funções principais para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_episodes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Associação dos dados da tabela a cada episódio\n",
    "\n",
    "<p align=\"justify\">\n",
    "A seguinte função \"insert_data_to_neo4j_appointments\", é responsavel por inserir dados de \"appointements\" extraídos do Oracle no Neo4j, criando nós para os compromissos e relacionando-os aos episódios, para isso, utiliza o comando MERGE para garantir que o nó do compromisso seja criado se não existir, ou atualizado se já existir e define as propriedades scheduled_on, appointment_date, appointment_time, iddoctor e idepisode para o nó do compromisso. Posteriormente, utiliza o comando MATCH para encontrar o episódio e o compromisso no banco de dados e cria um relacionamento HAS_APPOINTMENT entre o episódio e o compromisso usando o comando MERGE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_appointments():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_APPOINTMENT\n",
    "    sql_appointment = \"\"\"\n",
    "        SELECT \n",
    "            scheduled_on,\n",
    "            appointment_date,\n",
    "            appointment_time,\n",
    "            iddoctor,\n",
    "            idepisode\n",
    "        FROM \n",
    "            appointment\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_appointment)\n",
    "    appointments = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_appointments(appointments)\n",
    "\n",
    "def insert_data_to_neo4j_appointments(appointments):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        for appointment in appointments:\n",
    "            scheduled_on = appointment[0]\n",
    "            appointment_date = appointment[1]\n",
    "            appointment_time = appointment[2]\n",
    "            iddoctor = appointment[3]\n",
    "            idepisode = appointment[4]\n",
    "\n",
    "            # Criar nó de appointment\n",
    "            session.run(\"\"\"\n",
    "                MERGE (a:Appointment {scheduled_on: $scheduled_on, appointment_date: $appointment_date, appointment_time: $appointment_time, iddoctor: $iddoctor, idepisode: $idepisode})\n",
    "                SET a.scheduled_on = $scheduled_on,\n",
    "                    a.appointment_date = $appointment_date,\n",
    "                    a.appointment_time = $appointment_time,\n",
    "                    a.iddoctor = $iddoctor\n",
    "            \"\"\", {\n",
    "                \"scheduled_on\": scheduled_on,\n",
    "                \"appointment_date\": appointment_date,\n",
    "                \"appointment_time\": appointment_time,\n",
    "                \"iddoctor\": iddoctor,\n",
    "                \"idepisode\": idepisode\n",
    "            })\n",
    "\n",
    "            # Associar appointment ao episódio\n",
    "            session.run(\"\"\"\n",
    "                MATCH (e:Episode {idepisode: $idepisode})\n",
    "                MATCH (a:Appointment {scheduled_on: $scheduled_on, appointment_date: $appointment_date, appointment_time: $appointment_time, iddoctor: $iddoctor, idepisode: $idepisode})\n",
    "                MERGE (e)-[:HAS_APPOINTMENT]->(a)\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode,\n",
    "                \"scheduled_on\": scheduled_on,\n",
    "                \"appointment_date\": appointment_date,\n",
    "                \"appointment_time\": appointment_time,\n",
    "                \"iddoctor\": iddoctor\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "# Chamar a função principal para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_appointments()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extração e inserção dos Dados de Rooms\n",
    "<p align=\"justify\">\n",
    "A seguinte função \"insert_data_to_neo4j_rooms\", é responsável por extrair os dados dos quartos do Oracle e inseri-los no Neo4j, criando nós para os quartos e relacionando-os aos episódios, para isso, utiliza o comando MERGE para garantir que o nó do quarto seja criado se não existir, ou atualizado se já existir e define as propriedades room_type e room_cost para o nó do quarto. Posteriormente, utiliza o comando MATCH para encontrar o episódio e o quarto no banco de dados e cria um relacionamento HAS_ROOM entre o episódio e o quarto usando o comando MERGE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_rooms():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_ROOM e HOSPITALIZATION\n",
    "    sql_rooms = \"\"\"\n",
    "        SELECT \n",
    "            r.idroom,\n",
    "            r.room_type,\n",
    "            r.room_cost,\n",
    "            h.idepisode\n",
    "        FROM \n",
    "            room r\n",
    "        INNER JOIN hospitalization h ON r.idroom = h.room_idroom\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_rooms)\n",
    "    rooms = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_rooms(rooms)\n",
    "\n",
    "def insert_data_to_neo4j_rooms(rooms):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        for room in rooms:\n",
    "            idroom = room[0]\n",
    "            room_type = room[1]\n",
    "            room_cost = room[2]\n",
    "            idepisode = room[3]\n",
    "\n",
    "            # Criar nó de Room\n",
    "            session.run(\"\"\"\n",
    "                MERGE (r:Room {idroom: $idroom})\n",
    "                SET r.room_type = $room_type,\n",
    "                    r.room_cost = $room_cost\n",
    "            \"\"\", {\n",
    "                \"idroom\": idroom,\n",
    "                \"room_type\": room_type,\n",
    "                \"room_cost\": room_cost\n",
    "            })\n",
    "\n",
    "            # Associar Room ao episódio\n",
    "            session.run(\"\"\"\n",
    "                MATCH (e:Episode {idepisode: $idepisode})\n",
    "                MATCH (r:Room {idroom: $idroom})\n",
    "                MERGE (e)-[:HAS_ROOM]->(r)\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode,\n",
    "                \"idroom\": idroom\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "# Chamar a função para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_rooms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extração e inserção dos dados das Bills\n",
    "\n",
    "<p align=\"justify\">\n",
    "A seguinte função \"insert_data_to_neo4j_bills\", é responsável por inserir os dados de contas extraídos do Oracle no banco de dados Neo4j, criando nós para as contas e relacionando-as aos episódios, para isso utiliza o comando MERGE para garantir que o nó da conta seja criado se não existir, ou atualizado se já existir e define as propriedades room_cost, test_cost, other_charges, total, registered_at e payment_status para o nó da conta. Posteriormente, utiliza o comando MATCH para encontrar o episódio e a conta no banco de dados e cria um relacionamento HAS_BILL entre o episódio e a conta usando o comando MERGE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_bills():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_BILL\n",
    "    sql_bills = \"\"\"\n",
    "        SELECT \n",
    "            idbill,\n",
    "            room_cost,\n",
    "            test_cost,\n",
    "            other_charges,\n",
    "            total,\n",
    "            idepisode,\n",
    "            registered_at,\n",
    "            payment_status\n",
    "        FROM \n",
    "            bill\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_bills)\n",
    "    bills = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_bills(bills)\n",
    "\n",
    "def insert_data_to_neo4j_bills(bills):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        for bill in bills:\n",
    "            idbill = bill[0]\n",
    "            room_cost = bill[1]\n",
    "            test_cost = bill[2]\n",
    "            other_charges = bill[3]\n",
    "            total = bill[4]\n",
    "            idepisode = bill[5]\n",
    "            registered_at = bill[6]\n",
    "            payment_status = bill[7]\n",
    "\n",
    "            # Criar nó de Bill\n",
    "            session.run(\"\"\"\n",
    "                MERGE (b:Bill {idbill: $idbill})\n",
    "                SET b.room_cost = $room_cost,\n",
    "                    b.test_cost = $test_cost,\n",
    "                    b.other_charges = $other_charges,\n",
    "                    b.total = $total,\n",
    "                    b.registered_at = $registered_at,\n",
    "                    b.payment_status = $payment_status\n",
    "            \"\"\", {\n",
    "                \"idbill\": idbill,\n",
    "                \"room_cost\": room_cost,\n",
    "                \"test_cost\": test_cost,\n",
    "                \"other_charges\": other_charges,\n",
    "                \"total\": total,\n",
    "                \"registered_at\": registered_at,\n",
    "                \"payment_status\": payment_status\n",
    "            })\n",
    "\n",
    "            # Associar Bill ao episódio\n",
    "            session.run(\"\"\"\n",
    "                MATCH (e:Episode {idepisode: $idepisode})\n",
    "                MATCH (b:Bill {idbill: $idbill})\n",
    "                MERGE (e)-[:HAS_BILL]->(b)\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode,\n",
    "                \"idbill\": idbill\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "# Chamar a função para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_bills()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Extração e inserção dos dados de Lab Screenings\n",
    "<p align=\"justify\">\n",
    "A seguinte função \"insert_data_to_neo4j_lab_screenings\", é responsável por inserir os dados de exames laboratoriais extraídos do Oracle no banco de dados Neo4j, criando nós para os exames e relacionando-os aos episódios, para isso Utiliza o comando MERGE para garantir que o nó do exame seja criado se não existir, ou atualizado se já existir e define as propriedades test_cost, test_date e idtechnician para o nó do exame. Posteriormente, utiliza o comando MATCH para encontrar o episódio e o exame no banco de dados e cria um relacionamento HAS_LAB entre o episódio e o exame usando o comando MERGE.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_lab_screenings():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITAL_LAB_SCREENING\n",
    "    sql_lab_screenings = \"\"\"\n",
    "        SELECT \n",
    "            lab_id,\n",
    "            test_cost,\n",
    "            test_date,\n",
    "            idtechnician,\n",
    "            episode_idepisode\n",
    "        FROM \n",
    "            lab_screening\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_lab_screenings)\n",
    "    lab_screenings = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_lab_screenings(lab_screenings)\n",
    "\n",
    "def insert_data_to_neo4j_lab_screenings(lab_screenings):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        for lab_screening in lab_screenings:\n",
    "            lab_id = lab_screening[0]\n",
    "            test_cost = lab_screening[1]\n",
    "            test_date = lab_screening[2]\n",
    "            idtechnician = lab_screening[3]\n",
    "            idepisode = lab_screening[4]\n",
    "\n",
    "            # Criar nó de Lab Screening\n",
    "            session.run(\"\"\"\n",
    "                MERGE (l:LabScreening {lab_id: $lab_id})\n",
    "                SET l.test_cost = $test_cost,\n",
    "                    l.test_date = $test_date,\n",
    "                    l.idtechnician = $idtechnician\n",
    "            \"\"\", {\n",
    "                \"lab_id\": lab_id,\n",
    "                \"test_cost\": test_cost,\n",
    "                \"test_date\": test_date,\n",
    "                \"idtechnician\": idtechnician\n",
    "            })\n",
    "\n",
    "            # Associar Lab Screening ao episódio\n",
    "            session.run(\"\"\"\n",
    "                MATCH (e:Episode {idepisode: $idepisode})\n",
    "                MATCH (l:LabScreening {lab_id: $lab_id})\n",
    "                MERGE (e)-[:HAS_LAB]->(l)\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode,\n",
    "                \"lab_id\": lab_id\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "# Chamar a função para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_lab_screenings()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extração e inserção dos dados de Staff associados a cada episódio\n",
    "<p align=\"justify\">\n",
    "A seguinte função \"insert_data_to_neo4j_staff\", é responsável por inserir os dados de pessoal (médicos, enfermeiros e técnicos) extraídos do Oracle no banco de dados Neo4j, criando nós para o pessoal e relacionando-os aos episódios, para isso, a função percorre as listas de appointments, hospitalizations e lab_screenings, preenchendo um dicionário staff_dict onde a chave é o idepisode e os valores são os IDs do médico, enfermeiro e técnico. Para cada idepisode no dicionário staff_dict, a função realiza duas operações principais, a criação do Nó de Pessoal, onde utiliza o comando MERGE para garantir que o nó de pessoal seja criado se não existir, ou atualizado se já existir e define as propriedades doctor, nurse e technician para o nó de pessoal,o relacionamento do Pessoal com o Episódio, onde utiliza o comando MATCH para encontrar o episódio e o pessoal no banco de dados e cria um relacionamento HAS_STAFF entre o episódio e o pessoal usando o comando MERGE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_staff():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de APPOINTMENT\n",
    "    sql_appointment = \"\"\"\n",
    "        SELECT \n",
    "            iddoctor,\n",
    "            idepisode\n",
    "        FROM \n",
    "            appointment\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_appointment)\n",
    "    appointments = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de HOSPITALIZATION\n",
    "    sql_hospitalization = \"\"\"\n",
    "        SELECT \n",
    "            responsible_nurse,\n",
    "            idepisode\n",
    "        FROM \n",
    "            hospitalization\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_hospitalization)\n",
    "    hospitalizations = cursor.fetchall()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de LAB_SCREENING\n",
    "    sql_lab_screening = \"\"\"\n",
    "        SELECT \n",
    "            idtechnician,\n",
    "            episode_idepisode\n",
    "        FROM \n",
    "            lab_screening\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_lab_screening)\n",
    "    lab_screenings = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_staff(appointments, hospitalizations, lab_screenings)\n",
    "\n",
    "def insert_data_to_neo4j_staff(appointments, hospitalizations, lab_screenings):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        staff_dict = {}\n",
    "\n",
    "        for appointment in appointments:\n",
    "            iddoctor = appointment[0]\n",
    "            idepisode = appointment[1]\n",
    "            if idepisode not in staff_dict:\n",
    "                staff_dict[idepisode] = {\"doctor\": None, \"nurse\": None, \"technician\": None}\n",
    "            staff_dict[idepisode][\"doctor\"] = iddoctor\n",
    "\n",
    "        for hospitalization in hospitalizations:\n",
    "            responsible_nurse = hospitalization[0]\n",
    "            idepisode = hospitalization[1]\n",
    "            if idepisode not in staff_dict:\n",
    "                staff_dict[idepisode] = {\"doctor\": None, \"nurse\": None, \"technician\": None}\n",
    "            staff_dict[idepisode][\"nurse\"] = responsible_nurse\n",
    "\n",
    "        for lab_screening in lab_screenings:\n",
    "            idtechnician = lab_screening[0]\n",
    "            idepisode = lab_screening[1]\n",
    "            if idepisode not in staff_dict:\n",
    "                staff_dict[idepisode] = {\"doctor\": None, \"nurse\": None, \"technician\": None}\n",
    "            staff_dict[idepisode][\"technician\"] = idtechnician\n",
    "\n",
    "        for idepisode, staff in staff_dict.items():\n",
    "            # Criar nó de Staff\n",
    "            session.run(\"\"\"\n",
    "                MERGE (s:Staff {id: $idepisode})\n",
    "                SET s.doctor = $doctor,\n",
    "                    s.nurse = $nurse,\n",
    "                    s.technician = $technician\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode,\n",
    "                \"doctor\": staff[\"doctor\"],\n",
    "                \"nurse\": staff[\"nurse\"],\n",
    "                \"technician\": staff[\"technician\"]\n",
    "            })\n",
    "\n",
    "            # Associar Staff ao episódio\n",
    "            session.run(\"\"\"\n",
    "                MATCH (e:Episode {idepisode: $idepisode})\n",
    "                MATCH (s:Staff {id: $idepisode})\n",
    "                MERGE (e)-[:HAS_STAFF]->(s)\n",
    "            \"\"\", {\n",
    "                \"idepisode\": idepisode\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "# Chamar a função para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_staff()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Inserção dos dados de Staff\n",
    "<p align=\"justify\">\n",
    "A seguinte função \"insert_data_to_neo4j_staff\", é responsável por inserir os dados de pessoal (médicos, enfermeiros e técnicos) extraídos do Oracle no banco de dados Neo4j, criando nós para o pessoal e relacionando-os aos episódios, para isso, a função percorre as listas de appointments, hospitalizations e lab_screenings, preenchendo um dicionário staff_dict onde a chave é o idepisode e os valores são os IDs do médico, enfermeiro e técnico. Para cada idepisode no dicionário staff_dict, a função realiza duas operações principais, a criação do Nó de Pessoal, onde utiliza o comando MERGE para garantir que o nó de pessoal seja criado se não existir, ou atualizado se já existir e define as propriedades doctor, nurse e technician para o nó de pessoal,o relacionamento do Pessoal com o Episódio, onde utiliza o comando MATCH para encontrar o episódio e o pessoal no banco de dados e cria um relacionamento HAS_STAFF entre o episódio e o pessoal usando o comando MERGE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_data_from_oracle_staff_info():\n",
    "    # Pedir senha\n",
    "    password = getpass.getpass(prompt=\"Enter Oracle password: \")\n",
    "\n",
    "    # Conectar ao Oracle\n",
    "    connection = oracledb.connect(user=\"nosql\", password=password, dsn=\"localhost/xe\")\n",
    "    cursor = connection.cursor()\n",
    "\n",
    "    # Consulta SQL para extrair os dados de STAFF\n",
    "    sql_staff = \"\"\"\n",
    "        SELECT \n",
    "            EMP_ID,\n",
    "            EMP_FNAME,\n",
    "            EMP_LNAME,\n",
    "            DATE_JOINING,\n",
    "            DATE_SEPERATION,\n",
    "            EMAIL,\n",
    "            ADDRESS,\n",
    "            SSN,\n",
    "            IDDEPARTMENT,\n",
    "            IS_ACTIVE_STATUS\n",
    "        FROM \n",
    "            staff\n",
    "    \"\"\"\n",
    "    cursor.execute(sql_staff)\n",
    "    staff_info = cursor.fetchall()\n",
    "\n",
    "    # Fechar conexão\n",
    "    cursor.close()\n",
    "    connection.close()\n",
    "\n",
    "    # Inserir os dados no Neo4j\n",
    "    insert_data_to_neo4j_staff_info(staff_info)\n",
    "\n",
    "def insert_data_to_neo4j_staff_info(staff_info):\n",
    "    # Conectar ao Neo4j\n",
    "    neo4j_driver = GraphDatabase.driver(\"bolt://localhost:7687\", auth=(\"neo4j\", \"12345678\"))\n",
    "    with neo4j_driver.session() as session:\n",
    "        for info in staff_info:\n",
    "            emp_id = info[0]\n",
    "            \n",
    "            # Criar nó de Staff Information\n",
    "            session.run(\"\"\"\n",
    "                MERGE (si:StaffInfo {EMP_ID: $EMP_ID})\n",
    "                SET si.EMP_FNAME = $EMP_FNAME,\n",
    "                    si.EMP_LNAME = $EMP_LNAME,\n",
    "                    si.DATE_JOINING = $DATE_JOINING,\n",
    "                    si.DATE_SEPERATION = $DATE_SEPERATION,\n",
    "                    si.EMAIL = $EMAIL,\n",
    "                    si.ADDRESS = $ADDRESS,\n",
    "                    si.SSN = $SSN,\n",
    "                    si.IDDEPARTMENT = $IDDEPARTMENT,\n",
    "                    si.IS_ACTIVE_STATUS = $IS_ACTIVE_STATUS\n",
    "            \"\"\", {\n",
    "                \"EMP_ID\": info[0],\n",
    "                \"EMP_FNAME\": info[1],\n",
    "                \"EMP_LNAME\": info[2],\n",
    "                \"DATE_JOINING\": info[3],\n",
    "                \"DATE_SEPERATION\": info[4],\n",
    "                \"EMAIL\": info[5],\n",
    "                \"ADDRESS\": info[6],\n",
    "                \"SSN\": info[7],\n",
    "                \"IDDEPARTMENT\": info[8],\n",
    "                \"IS_ACTIVE_STATUS\": info[9]\n",
    "            })\n",
    "            \n",
    "            # Associar StaffInfo ao Staff (doctor, nurse, technician)\n",
    "            session.run(\"\"\"\n",
    "                MATCH (s:Staff)\n",
    "                WHERE s.doctor = $EMP_ID OR s.nurse = $EMP_ID OR s.technician = $EMP_ID\n",
    "                MATCH (si:StaffInfo {EMP_ID: $EMP_ID})\n",
    "                MERGE (s)-[:HAS_INFO]->(si)\n",
    "            \"\"\", {\n",
    "                \"EMP_ID\": emp_id\n",
    "            })\n",
    "\n",
    "    # Fechar conexão\n",
    "    neo4j_driver.close()\n",
    "\n",
    "# Chamar a função para extrair dados do Oracle e inseri-los no Neo4j\n",
    "extract_data_from_oracle_staff_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexação Neo4j\n",
    "\n",
    "<p align=\"justify\">\n",
    "A indexação no Neo4j é um recurso fundamental para otimizar a eficiência das consultas nos bancos de dados orientados a grafos. Este recurso é especialmente valioso em contextos onde grandes volumes de dados estão envolvidos e a rapidez nas respostas é crucial. No Neo4j, a indexação permite um acesso mais rápido a nós e relações, utilizando propriedades específicas como referências.\n",
    "\n",
    "<p align=\"justify\">\n",
    "Quando um índice é criado numa propriedade de um nó, como por exemplo o nome de um usuário, o Neo4j utiliza esse índice para acelerar as buscas que filtram, baseadas nessa propriedade específica. Isso elimina a necessidade de percorrer todo o grafo para encontrar os nós desejados, o que seria consideravelmente mais lento. Essa capacidade torna as operações de busca não apenas mais eficientes, mas também mais escaláveis à medida que o volume de dados cresce.\n",
    "\n",
    "<p align=\"justify\">\n",
    "A criação de índices é feita através da linguagem de consulta Cypher, que é nativa do Neo4j. Por exemplo, para indexar uma propriedade de nome de usuário em nós do tipo “Usuário”, o comando seria algo como CREATE INDEX FOR (u:User) ON (u.username). Este comando instrui o Neo4j a preparar uma estrutura de dados especial que facilita buscas rápidas baseadas no nome de usuário.\n",
    "\n",
    "<p align=\"justify\">\n",
    "Além de melhorar a performance das consultas, a indexação tem impactos significativos no planeamento e manutenção de sistemas que utilizam Neo4j. Embora seja uma poderosa ferramenta de otimização, índices requerem espaço adicional de armazenamento e podem tornar as operações de escrita ligeiramente mais lentas, já que cada atualização nos dados requer também uma atualização nos índices. Portanto, é crucial avaliar cuidadosamente quais propriedades se beneficiarão mais da indexação, a fim de equilibrar os benefícios com os custos associados.\n",
    "\n",
    "<p align=\"justify\">\n",
    "Com o objetivo de melhorar o desempenho das consultas, criou-se índices no Neo4j para aquelas consultas que são executadas frequentemente:\n",
    "\n",
    "- Indexação de Pacientes (Patient):\n",
    "    - ID do Paciente (idpatient): Essencial para buscas rápidas e relacionamentos.\n",
    "\n",
    "- Indexação de Episódios Médicos (Episode):\n",
    "    - ID do Episódio (idepisode): Crucial para associar episódios a pacientes e outras entidades relacionadas, como consultas, contas e exames.\n",
    "\n",
    "- Indexação de Consultas Médicas (Appointment):\n",
    "    - ID do Médico (iddoctor) e ID do Episódio (idepisode): Importante para buscar consultas específicas e associá-las aos episódios médicos.\n",
    "\n",
    "- Indexação de Quartos de Hospital (Room):\n",
    "    - ID do Quarto (idroom): Útil para buscas de alocação de pacientes em quartos específicos.\n",
    "\n",
    "- Indexação de Contas Hospitalares (Bill):\n",
    "    - ID da Conta (idbill): Fundamental para acessar rapidamente detalhes financeiros.\n",
    "\n",
    "- Indexação de Exames de Laboratório (LabScreening):\n",
    "    - ID do Laboratório (lab_id): Essencial para acessar rapidamente os exames de laboratório de um paciente específico.\n",
    "\n",
    "<p align=\"justify\">\n",
    "Cada um desses índices otimiza o desempenho ao reduzir o tempo necessário para localizar nós específicos em consultas comuns. Por exemplo, ao indexar idpatient em Patient, o Neo4j pode encontrar rapidamente todos os nós de pacientes específicos, assim como as suas relações com episódios, consultas, e outros dados relevantes sem a necessidade de percorrer todo o banco de dados.\n",
    "<p align=\"justify\">\n",
    "A utilização de índices é um recurso valioso para garantir a eficiência operacional, especialmente em ambientes de dados grandes e complexos como os encontrados nos sistemas de informação hospitalar.\n",
    "\n",
    "**Nota:** O código aqui apresentado está escrito em cypher \n",
    "\n",
    "- Índices para Pacientes (Patients)\n",
    "    - // Índice composto para data de nascimento e gênero\n",
    "\n",
    "        CREATE INDEX FOR (p:Patient) ON (p.BIRTHDAY, p.gender)\n",
    "\n",
    "    - // Índice para número de seguro\n",
    "\n",
    "        CREATE INDEX FOR (p:Patient) ON (p.policy_number)\n",
    "\n",
    "- Índices para Consultas Médicas (Appointments)\n",
    "    - // Índice para data agendada\n",
    "\n",
    "        CREATE INDEX FOR (a:Appointment) ON (a.scheduled_on)\n",
    "\n",
    "    - // Índice composto para médico e data da consulta\n",
    "\n",
    "        CREATE INDEX FOR (a:Appointment) ON (a.iddoctor, a.appointment_date)\n",
    "\n",
    "- Índices para Serviços (Services)\n",
    "    - // Índice para identificação da fatura\n",
    "\n",
    "        CREATE INDEX FOR (s:Service) ON (s.idbill)\n",
    "\n",
    "    - // Índice para identificação do exame de laboratório\n",
    "\n",
    "        CREATE INDEX FOR (s:Service) ON (s.lab_id)\n",
    "\n",
    "- Índices para Funcionários (Staff)\n",
    "    - // Índice para identificação do departamento\n",
    "\n",
    "        CREATE INDEX FOR (sa:Staff) ON (sa.departmentId)\n",
    "\n",
    "    - // Índice para tipo de funcionário\n",
    "\n",
    "        CREATE INDEX FOR (sa:Staff) ON (sa.type)\n",
    "\n",
    "\n",
    "Com o intuito de verificar a perfomance e a utilidade da indexação criada criaram-se as seguintes consultas\n",
    "\n",
    "- Consultas para Pacientes (Patients) - Buscar Pacientes por Data de Nascimento e Gênero:\n",
    "\n",
    "    MATCH (p:Patient)\n",
    "    WHERE p = '1990-01-01' AND p.gender = 'M'\n",
    "    RETURN p\n",
    "\n",
    "- Consultas para Pacientes (Patients) - Buscar Paciente por Número de Seguro:\n",
    "\n",
    "    MATCH (p:Patient)\n",
    "    WHERE p.policy_number = 'PN123456'\n",
    "    RETURN p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Queries Neo4j\n",
    "\n",
    "Com o objetivo de demonstrar a operabilidade da base de dados criada no Neo4j foram desenvolvidas as seguintes consultas de modo a demonstrar possívies aplicações da base de dados desenvolvida\n",
    "\n",
    "**Nota:** O código apresentado foi escrito em cypher\n",
    "\n",
    "- Informação sobre os quartos:\n",
    "\n",
    "    MATCH (r:Room)<-[h:HAS_ROOM]-(episode:Episode)\n",
    "    RETURN r.idroom, r.room_type, r.room_cost, episode.idepisode;\n",
    "\n",
    "- Enfermeira responsável por episódio:\n",
    "\n",
    "    MATCH (episode:Episode)-[hs:HAS_STAFF]->(staff:Staff)\n",
    "    RETURN staff.nurse AS responsible_nurse, episode.idepisode;\n",
    "\n",
    "- Staff por episódio:\n",
    "\n",
    "    MATCH (episode:Episode)-[hs:HAS_STAFF]->(staff:Staff)\n",
    "    RETURN episode.idepisode AS episode_id, \n",
    "           staff.doctor AS doctor_id,\n",
    "        staff.technician AS technician_id,\n",
    "        staff.nurse AS nurse_id;\n",
    "\n",
    "- Informações sobre os pacientes, episódios, quartos e contas associadas:\n",
    "\n",
    "    MATCH (p:Patient)-[:HAS_EPISODE]->(e:Episode)-[:HAS_ROOM]->(r:Room), \n",
    "        (e)-[:HAS_BILL]->(b:Bill)\n",
    "    RETURN p, e, r, b;\n",
    "\n",
    "- Consultar Dados de lab_screening\n",
    "\n",
    "    MATCH (l:LabScreening)\n",
    "    RETURN l.lab_id, l.test_cost, l.test_date, l.idtechnician, l.episode_idepisode;\n",
    "\n",
    "- Consultar Dados de appointment, hospitalization e lab_screening para Staff\n",
    "\n",
    "    - Consulta para Appointment:\n",
    "\n",
    "        MATCH (a:Appointment)\n",
    "        RETURN a.iddoctor, a.idepisode;\n",
    "\n",
    "\n",
    "    - Consulta para Hospitalization:\n",
    "        \n",
    "        MATCH (h:Hospitalization)\n",
    "        RETURN h.responsible_nurse, h.idepisode;\n",
    "\n",
    "    - Consulta para Lab Screening:\n",
    "\n",
    "        MATCH (l:LabScreening)\n",
    "        RETURN l.idtechnician, l.episode_idepisode;\n",
    "\n",
    "- Consultar Todos os Episódios com Exames de Laboratório Realizados:\n",
    "\n",
    "    MATCH (e:Episode)-[:HAS_LAB]->(l:LabScreening)\n",
    "    RETURN e, l;\n",
    "\n",
    "- Consultar Dados de bill:\n",
    "    \n",
    "    MATCH (b:Bill)\n",
    "    RETURN b.idbill, b.room_cost, b.test_cost, b.other_charges, b.total, b.idepisode, b.registered_at, b.payment_status;\n",
    "\n",
    "- Consultar Dados de appointment\n",
    "\n",
    "    MATCH (a:Appointment)\n",
    "    RETURN a.scheduled_on, a.appointment_date, a.appointment_time, a.iddoctor, a.idepisode;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusão\n",
    "\n",
    "Ao selecionar uma base de dados NoSQL, duas opções destacam-se: MongoDB e Neo4j. Cada uma oferece vantagens e desvantagens distintas.\n",
    "\n",
    "O MongoDB destaca-se devido à flexibilidade do esquema, permitindo o armazenamento de documentos não estruturados ou em constante mudança sem a necessidade de um esquema predefinido. Esta característica é útil para dados dinâmicos e em constante evolução. Além disso, o MongoDB oferece excelente desempenho para operações como consultas, agregações e triggers, garantindo respostas rápidas e eficientes.\n",
    "\n",
    "No entanto, a flexibilidade do MongoDB também apresenta desafios na migração de dados de bancos de dados relacionais. O processo pode ser complexo e levar à duplicação de dados ou à perda de informações cruciais. Além disso, a natureza flexível do esquema pode dificultar a manutenção da consistência dos dados, especialmente em ambientes distribuídos.\n",
    "\n",
    "Em contrapartida, o Neo4j destaca-se pela estrutura de grafos, ideal para armazenar e gerenciar dados inter-relacionados, como redes sociais ou mapas mentais. Este modelo de dados permite consultas complexas e eficientes em relações entre entidades, tornando-o ideal para a exploração de conexões e interdependências.\n",
    "\n",
    "Um dos pontos fortes do Neo4j é sua capacidade de lidar com dados repetidos sem gerar erros. Ao inserir dados duplicados, o Neo4j simplesmente atualiza as informações existentes, evitando problemas de consistência e simplificando o processo de gerenciamento de dados. Além disso, o uso de índices no Neo4j é menos relevante do que no MongoDB, pois o modelo de grafo já otimiza as consultas por natureza.\n",
    "\n",
    "No entanto, o Neo4j exige um planejamento cuidadoso do esquema antes de armazenar dados. Essa rigidez pode ser um obstáculo para dados em constante mudança, exigindo constantes adaptações do modelo.\n",
    "\n",
    "O Neo4j revelou-se como a melhor alternativa ao modelo relacional do hospital, devido à capacidade de lidar com dados inter-relacionados, à ausência de erros em inserções duplicadas, à menor relevância de índices, à flexibilidade do modelo lógico e ao excelente desempenho para consultas complexas. A migração de dados e a curva de aprendizado podem ser desafios, mas com planejamento e recursos adequados, a transição para o Neo4j trará benefícios significativos.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}