Apuntes Juan Carlitos
---------------------Primos Hermanos---------------
CREATE OR REPLACE FUNCTION primoHermanos(R1 number, R2 number)
RETURN integer AS
p1 number;
m1 number;
p2 number;
m2 number;
ph integer;
BEGIN
SELECT rutPadre, rutMadre INTO p1, m1 FROM PERSONAS WHERE rut = R1;
SELECT rutPadre, rutMadre INTO p2, m2 FROM PERSONAS WHERE rut = R2;
ph :=
sonHermanos(p1,p2);
ph := ph + sonHermanos(p1, m2);
ph := ph + sonHermanos(m1, p2);
ph := ph + sonHermanos(m1, m2);
return ph;
END;
/
---------------------------------------------------
----------------Ejercicio Uno----------------------
CREATE OR REPLACE PROCEDURE abuelos(elRut IN number) as
    rutAbuelo INTEGER;
    rutAbuela INTEGER;
    rutP INTEGER;
    rutM INTEGER;
    abuelo nombre%type;
    abuela nombre%type;
BEGIN
    SELECT rutpadre, rutmadre INTO rutP, rutM FROM personas WHERE rut = elRut;
    DBMS_OUTPUT.PUT_LINE("Abuelos de parte del padre");
    SELECT rutpadre,rutmadre INTO rutAbuelo, rutAbuela FROM personas WHERE rut = rutP;
    SELECT nombre INTO abuelo FROM personas WHERE rut = rutAbuelo;
    SELECT nombre INTO abuela FROM personas WHERE rut =rutAbuela;
    DBMS_OUTPUT.PUT_LINE("Abuelo: "||abuelo);
    DBMS_OUTPUT.PUT_LINE("Abuela: "||abuela);

    DBMS_OUTPUT.PUT_LINE("Abuelos de parte de la madre");
    SELECT rutpadre, rutmadre INTO rutAbuelo, rutAbuela FROM personas WHERE rut = rutM;
    SELECT nombre INTO abuelo FROM personas WHERE rut = rutAbuelo;
    SELECT nombre INTO abuela FROM personas WHERE rut = rutAbuela;
    DBMS_OUTPUT.PUT_LINE("Abuelo: "||abuelo);
    DBMS_OUTPUT.PUT_LINE("Abuela: "||abuela);
END;
-------------------------------------------------
------------------Ejercicio Dos------------------
CREATE OR REPLACE FUNCTION sonHermanos(rutUno IN number, rutDOs IN number)
RETURN INTEGER AS
    p1 number;
    m1 number;
    p2 number;
    m2 number;
    tipoHermano INTEGER;
BEGIN
    tipoHermano := 0;
    SELECT rutpadre, rutmadre INTO p1, m1 FROM personas WHERE rut = rutUno;
    SELECT rutpadre, rutmadre INTO p2, m2 FROM personas WHERE rut = rutDOs;

    IF (p1 = p2 and m1 = m2) THEN
        tipoHermano := 3;
    ELSIF (m1 = m2) THEN
        tipoHermano := 1;
    ELSIF (p1 = p2) THEN
        tipoHermano := 2;
    END IF;
    return tipoHermano;
END;
/
--------------------------------------------------
--------------------Ejercicio tres----------------
CREATE OR REPLACE PROCEDURE matrizHermanos AS
    type losHermanos IS ARRAY(4) OF INTEGER;
    th losHermanos;
    tht losHermanos;
    CURSOR hermanosUNO IS
    SELECT * FROM PERSONAS;
    h1 hermanos%ROWTYPE;
    CURSOR hermanoDOS IS
    SELECT * FROM PERSONAS;
    h2 hermanos%ROWTYPE;
    tHermano INTEGER;
BEGIN
    tHermano := 0;
    th := losHermanos(0,0,0,0);
    tht := losHermanos(0,0,0,0);
    tht(1) := 0; tht(2) := 0; tht(3) := 0; tht(4) := 0;
    DBMS_OUTPUT.PUT_LINE("Nombre        1   2   3   total");
    DMBS_OUTPUT.PUT_LINE("----------------------------------------------");
    FOR h1 IN hermanoUNO LOOP
        th(1) := 0; th(2) := 0; th(3) := 0; th(4) := 0;
        FOR h2 IN hermanoDOS LOOP
            IF (tHermano <> 0) THEN
                tHermano sonHermanos(h1,h2);
                th(tHermano) := th(tHermano) + 1;
                tht(tHermano) := tht(tHermano) + 1;
                th(4) := th(4) + 1;
                tht(4) := tht(4) + 1;
            END IF;
        END LOOP;
        DBMS_OUTPUT.PUT_LINE(h1.nombre||"   "||th(1)||" "||th(2)||" "||th(3)||" "||th(4));
    END LOOP;
    DBMS_OUTPUT.PUT_LINE("Total "||tht(1)||"    "||tht(2)||"    "||tht(3)||"    "||tht(4));
END;
-----------------------------------------------
----------------Ejercicio Cuatro---------------
CREATE OR REPLACE TRIGGER sonHermanos_tg
BEFORE INSERT ON personas
FOR EACH ROW
DECLARE
    hp INTEGER;
    hm INTEGER;
BEGIN
    hp := sonHermanos(:NEW.rut, :NEW.rutPadre);
    hm := sonHermanos(:NEW:rut, :NEW.rutMadre);
    IF(hp <> 0 AND hm <> 0) THEN
        raise_application_error(-20000,:NEW.NOMBRE||" es hermano de uno de sus padres");
    END IF;
END;
-----------------------------------------------
------------------Ejercicio Cinco--------------
import java.sql.*;

public class phsg {
    public static void main (String args []) throws SQLException){
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
        Connection conn DriverManager.getConnection
         ("jdbc:oracle:thin:@colvin.chillan.ubiobio.cl:1521:orcl","name","pass");
        Statement stmt = conn.createStatement();

        ResultSet rs = stmt.executeQuery("SELECT RutPadre, RutMadre FROM personas WHERE");
        rs.next();
        int padre = rs.getInt(1);
        int madre = rs.getInt(2);
        int p1;
        int p2;
        CallableStatement cs1 = conn.prepareCall("begin ? := sonHermanos(?,?); end;");
        cs1.registerOutParameter(1,Types.INTEGER);
        rs = stmt.executeQuery("SELECT NOMBRE, RutPadre, RutMadre FROM PERSONAS WHERE RUT <> 10 AND RutPadre IS NOT NULL and RutMadre IS NOT NULL");
        boolean flag = false;
        while(rs.next(){
            String nombre = rs.getString(1);
            p1 = rs.getInt(2);
            p2 = rs.getInt(3);
            flag = sonPrimosHermanos(padre,p1,conn,cs1)||
                sonPrimosHermanos(padre,p2,conn,cs1)||
                sonPrimosHermanos(madre,p1,conn,cs1)||
                sonPrimosHermanos(madre,p2,conn,cs1;
            if(flag) System.out.println(nombre);
        }
        stmt.close();

    }

    public boolean sonPrimosHermanos(INT H1, INT H2, Connection conn, CallableStatement cs1){
        cs1.setInt(2,h1);
        cs1.setInt(3,h2);
        cs1.excuteUpdate;
        int resultado = cs1.getInt(1);
        return resultado <> 0;
    }
}
-------------------------------------------------
--------------------ObtenerMayorArea-------------
import java.util.Scanner;
import java.sql.*;
public class obtenerMayorArea{
        public static void main (String args[]) throws SQLException{
                Scanner tec = new Scanner(System.in);
                System.out.print("Obtener areas de rectangulos mayores que el rectangulo con id: ");
        int idC = tec.nextInt();

        //Instalar drivers
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

        //Establecer conexion
        Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@oracle.localdomain:1521:orcl","juan.ortiz1601","askjzxmnqwpo19");

        //Realizar consulta
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT RID FROM RECTANGULO WHERE RID <> "+idC);

        //Calcular area de  rectangulo solicitado
        CallableStatement cs = conn.prepareCall("begin ? :=rectangleTools.Area(?);end;");
        cs.registerOutParameter(1,Types.DOUBLE);
        cs.setInt(2,idC);
        cs.executeUpdate();
        double a = cs.getDouble(1);
        System.out.println("Area del rectangulo "+idC+" es "+a);

        //Comparar con el area de los demas rectangulos
        int idAux = 0;
        double area = 0;
        System.out.println("A continuacion, los rectangulos mayores");
        while(rs.next()){
            idAux = rs.getInt("RID");
            cs.setInt(2,idAux);
            cs.executeUpdate();
            area = cs.getDouble(1);
            if(area>a){
                System.out.println("Area del rectangulo "+idAux+" es "+area);
            }
        }
        cs.close();
        stmt.close();
        }
}
-----------------------------------------------------
----------------------Inser Amigo--------------------
import java.util.Scanner;
import java.sql.*;
public class insertarAmigos{
    public static void main(String args[])throws SQLException{
        Scanner tec = new Scanner(System.in);
        //Cargar driver
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
        //Establecer conexion con la base de datos
        Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@oracle.localdomain:1521:orcl", "juan.ortiz1601", "askjzxmnqwpo19");



        PreparedStatement ps = conn.prepareStatement("INSERT INTO AMIGOS VALUES(?,?,?,?,?,NULL,NULL)");

        while(true){
            //Solicitar datos
            System.out.println("---- datos del amigo ----");
            System.out.print("ID (-1 --> termina) :");
            int elId = tec.nextInt();

            //Si es menor que 0, termina el programa
            if(elId<0){
                ps.close();
                System.exit(-1);
            }

            System.out.print("Nombre: ");
            String nombre = tec.next();

            System.out.print("Celular: ");
            int celular = tec.nextInt();

            System.out.print("Fecha Nacimiento (aaaa-mm-dd): ");
            Date fechaNac = Date.valueOf(tec.next());

            System.out.print("Sexo (M/F): ");
            String sexo = tec.next();

            ps.setInt(1,elId);
            ps.setString(2,nombre);
            ps.setInt(3,celular);
            ps.setDate(4,fechaNac);
            ps.setString(5,sexo);
            ps.executeUpdate();
        }
    }
}
-----------------------------------------------------
----------------Lab 4 Ej1----------------------------
public class familiares{
    public static void main(String []args) throws SQLException{
        Scanner tec = new Scanner(System.in);
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

        Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@oracle.localdomain:1521:orcl","juan.ortiz1601","askjzxmnqwpo19");
        Statement stmt = conn.createStatement();

        System.out.print("ID: ");
        int id = tec.nextInt();
        boolean flag = verificarId(id, stmt);
        if(!flag) System.exit(-1);

        mostrarMenu();
        int parentesco = tec.nextInt();

        //Variables
        int papaMama[] = new int[2];
        int papaMamaP[] = new int[2];
        int papaMamaM[] = new int[2];
        String mama = null;
        String papa = null;

        switch(parentesco) {
            case 1:
                int idPadre = 0;
                int idMadre = 0;
                ResultSet rs = stmt.executeQuery ("SELECT idPadre, idMadre FROM AMIGOS where id = " + id);
                while (rs.next ( )) {
                    idPadre = rs.getInt ("idPadre");
                    idMadre = rs.getInt ("idMadre");
                }
                if (idPadre != 0) {
                    String nombreP = solicitarNombre (idPadre, stmt);
                    System.out.println ("Padre: " + nombreP);
                } else {
                    System.out.print ("Sin padre");
                }
                if (idMadre != 0) {
                    String nombreM = solicitarNombre (idMadre, stmt);
                    System.out.println ("Madre: " + nombreM);
                } else {
                    System.out.println ("Sin madre");
                }
                break;
            case 2:
                String abueloP = null;
                String abuelaP = null;
                String abueloM = null;
                String abuelaM = null;
                papaMama = solicitarPadres (id, stmt);
                papaMamaP = solicitarPadres (papaMama[0], stmt);
                papaMamaM = solicitarPadres (papaMama[1], stmt);


                if (papaMamaP[0] != 0) abueloP = solicitarNombre (papaMamaP[0], stmt);
                System.out.println ("Abuelo paterno: " + abueloP);
                if (papaMamaP[1] != 0) abuelaP = solicitarNombre (papaMamaP[1], stmt);
                System.out.println ("Abuela paterno: " + abuelaP);
                if (papaMamaM[0] != 0) abueloM = solicitarNombre (papaMamaM[0], stmt);
                System.out.println ("Abuelo materno: " + abueloM);
                if (papaMamaM[1] != 0) abuelaM = solicitarNombre (papaMamaM[1], stmt);
                System.out.println ("Abuela materna: " + abuelaM);


                break;
            case 3:
                List<String> hijos = solicitarHijos (id, stmt);
                for (String i : hijos) {
                    System.out.println (i);
                }
                break;
            case 4:
                papaMama = solicitarPadres (id, stmt);
                List<String> hermanoUno = solicitarHijos (papaMama[0], stmt);
                String nombre = solicitarNombre (id, stmt);
                List<String> hermanoDos = solicitarHijos (papaMama[1], stmt);
                for (String hermano : hermanoUno) {
                    if (nombre.equals (hermano)) {

                    } else {
                        System.out.println (hermano);
                    }
                }
                for (String hermano : hermanoDos) {
                    if (nombre.equals (hermano)) {

                    } else {
                        System.out.println (hermano);
                    }
                }
                break;
            case 5:
                papaMama = solicitarPadres (id, stmt);
                papaMamaP = solicitarPadres (papaMama[0], stmt);
                papaMamaM = solicitarPadres (papaMama[1], stmt);
                List<String> tiosUno = solicitarHijos (papaMamaP[0], stmt);
                List<String> tiosDos = solicitarHijos (papaMamaP[1], stmt);
                List<String> tiosTres = solicitarHijos (papaMamaM[0], stmt);
                List<String> tiosCuatro = solicitarHijos (papaMamaM[1], stmt);
                papa = solicitarNombre (papaMama[0], stmt);
                mama = solicitarNombre (papaMama[1], stmt);
                for (String tios : tiosUno) {
                    if (tios.equals (papa) || tios.equals (mama)) {

                    } else {
                        System.out.println (tios);
                    }
                }
                for (String tios : tiosDos) {
                    if (tios.equals (papa) || tios.equals (mama)) {

                    } else {
                        System.out.println (tios);
                    }
                }
                for (String tios : tiosTres) {
                    if (tios.equals (papa) || tios.equals (mama)) {

                    } else {
                        System.out.println (tios);
                    }
                }
                for (String tios : tiosCuatro) {
                    if (tios.equals (papa) || tios.equals (mama)) {

                    } else {
                        System.out.println (tios);
                    }
                }
                break;
            case 6:
                papaMama = solicitarPadres (id, stmt);
                papaMamaP = solicitarPadres (papaMama[0], stmt);
                papaMamaM = solicitarPadres (papaMama[1], stmt);
                List<Integer> tios1 = solicitarHijosID (papaMamaP[0], stmt);
                List<String> hijosUno = null;
                List<String> hijosDos = null;
                List<String> hijosTres = null;
                List<String> hijosCuatro = null;
                for (int losTios : tios1) {
                    hijosUno = solicitarHijos (losTios, stmt);
                }
                List<Integer> tios2 = solicitarHijosID (papaMamaP[1], stmt);
                for (int losTios : tios2) {
                    hijosDos = solicitarHijos (losTios, stmt);
                }
                List<Integer> tios3 = solicitarHijosID (papaMamaM[0], stmt);
                for (int losTios : tios3) {
                    hijosTres = solicitarHijos (losTios, stmt);
                }
                List<Integer> tios4 = solicitarHijosID (papaMamaM[1], stmt);
                for (int losTios : tios4) {
                    hijosCuatro = solicitarHijos (losTios, stmt);
                }
                nombre = solicitarNombre (id, stmt);
                for (String hijo : hijosUno) {
                    if (hijo.equals (nombre)) {

                    } else {
                        System.out.println (hijo);
                    }
                }

                for (String hijo : hijosDos) {
                    if (hijo.equals (nombre)) {

                    } else {
                        System.out.println (hijo);
                    }
                }

                for (String hijo : hijosTres) {
                    if (hijo.equals (nombre)) {

                    } else {
                        System.out.println (hijo);
                    }
                }

                for (String hijo : hijosCuatro) {
                    if (hijo.equals (nombre)) {

                    } else {
                        System.out.println (hijo);
                    }
                }

                break;
            default:
                System.out.println ("Ha ingresado una opcion incorrecta");
        }
    }

    public static List<Integer> solicitarHijosID(int id, Statement stmt) throws SQLException{
        List<Integer> hijos = new LinkedList<>();
        ResultSet rs = stmt.executeQuery("SELECT id FROM AMIGOS where idPadre = "+id);
        while(rs.next()){
            hijos.add(rs.getInt("id"));
        }
        rs = stmt.executeQuery("SELECT id FROM AMIGOS where idMadre = "+id);
        while(rs.next()){
            hijos.add(rs.getInt("id"));
        }
        return hijos;
    }

    public static List<String> solicitarHijos(int id, Statement stmt) throws SQLException{
        List<String> hijos = new LinkedList<>();
        ResultSet rs = stmt.executeQuery("SELECT nombre FROM AMIGOS where idPadre = "+id);
        while(rs.next()){
            hijos.add(rs.getString("nombre"));
        }
        rs = stmt.executeQuery("SELECT nombre FROM AMIGOS where idMadre = "+id);
        while(rs.next()){
            hijos.add(rs.getString("nombre"));
        }
        return hijos;
    }

    public static int [] solicitarPadres(int id, Statement stmt) throws SQLException{
        ResultSet rs = stmt.executeQuery("SELECT idPadre, idMadre FROM AMIGOS where id = "+id);
        rs.next();
        int idPadre = rs.getInt("idPadre");
        int idMadre = rs.getInt("idMadre");
        int papaMama[] = new int[2];
        papaMama[0] = idPadre;
        papaMama[1] = idMadre;
        return papaMama;
    }

    public static String solicitarNombre(int id,Statement stmt) throws SQLException{
        ResultSet rs = stmt.executeQuery("SELECT nombre FROM amigos WHERE id = "+id);
        rs.next();
        return rs.getString("nombre");
    }

    public static boolean verificarId(int id, Statement stmt) throws SQLException{
        ResultSet rs = stmt.executeQuery("SELECT id FROM amigos");
        while(rs.next()){
            if(rs.getInt("id") == id){
                return true;
            }
        }
        return false;
    }

    public static void mostrarMenu(){
        System.out.println("Parentesco: ");
        System.out.println("1. padres");
        System.out.println("2. abuelos");
        System.out.println("3. hijos");
        System.out.println("4. hermanos");
        System.out.println("5. tios");
        System.out.println("6. primos");
    }
}
-----------------------------------------------------
-------------------Lab 4 ej2-------------------------
public class ejercicioDos {
    public static void main(String[] args) throws SQLException{
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

        Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@colvin.chillan.ubiobio.cl:1521:orcl","juan.ortiz1601","askjzxmnqwpo19");
        Statement stmt = conn.createStatement();
        CallableStatement cs = conn.prepareCall("begin ? := RectangleTools.puntoenRectangulo(?,?,?); end;");
        cs.registerOutParameter(1, Types.INTEGER);

        //Variables
        int id1 = 2;
        int id2 = 4;
        int [] axy1 = new int [2], bxy1 = new int [2], cxy1 = new int [2], dxy1 = new int[2];
        int [] axy2 = new int [2], bxy2 = new int [2], cxy2 = new int [2], dxy2 = new int[2];
        boolean flag1 = false, flag2 = false, flag3 = false, flag4 = false;

        ResultSet rs = stmt.executeQuery("SELECT * FROM RECTANGULO WHERE rid = "+id1);
        if(!rs.next())System.exit(0);
        bxy1[0] = rs.getInt(4); bxy1[1] = rs.getInt(5);//XH, YH
        cxy1[0] = rs.getInt(2); cxy1[1] = rs.getInt(3);//XL, YL
        axy1[0] = cxy1[0]; axy1[1] = bxy1[1];//XL,YH
        dxy1[0] = bxy1[0]; dxy1[1] = cxy1[1];//XH,YL

        rs = stmt.executeQuery("SELECT * FROM RECTANGULO WHERE RID = "+id2);
        if(!rs.next()) System.exit(0);
        bxy2[0] = rs.getInt(4); bxy2[1] = rs.getInt(5);//XH, YH
        cxy2[0] = rs.getInt(2); cxy2[1] = rs.getInt(3);//XL, YL
        axy2[0] = cxy2[0]; axy2[1] = bxy2[1];//XL,YH
        dxy2[0] = bxy2[0]; dxy2[1] = cxy2[1];//XH,YL

        cs.setDouble(4, id2);//id
        cs.setDouble(2, bxy1[0]);
        cs.setDouble(3, bxy1[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag1 = true;

        cs.setDouble(2, cxy1[0]);
        cs.setDouble(3, cxy1[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag2 = true;

        cs.setDouble(2, axy1[0]);
        cs.setDouble(3, axy1[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag3 = true;

        cs.setDouble(2, dxy1[0]);
        cs.setDouble(3, dxy1[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag4 = true;

        if(flag1 && flag2 && flag3 && flag4){
            System.out.println("El rectangulo con ID = "+id1+" es subconjunto del rectangulo con ID = "+id2);
            System.exit(0);
        }
        else{
            if (flag1 || flag2 || flag3 || flag4) {
                System.out.println("El rectangulo con ID = "+id1+" y el rectangulo con ID = "+id2+" se intersectan");
                System.exit(0);
            }
        }
        flag1 = false;
        flag2 = false;
        flag3 = false;
        flag4 = false;

        cs.setDouble(4, id1);//id
        cs.setDouble(2, bxy2[0]);
        cs.setDouble(3, bxy2[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag1 = true;

        cs.setDouble(2, cxy2[0]);
        cs.setDouble(3, cxy2[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag2 = true;

        cs.setDouble(2, axy2[0]);
        cs.setDouble(3, axy2[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag3 = true;

        cs.setDouble(2, dxy2[0]);
        cs.setDouble(3, dxy2[1]);
        cs.executeUpdate();
        if(cs.getInt(1) == 1) flag4 = true;

        if(flag1 && flag2 && flag3 && flag4){
            System.out.println("El rectangulo con ID = "+id2+" es subconjunto del rectangulo con ID = "+id1);
            System.exit(0);
        }
        else{
            if (flag1 || flag2 || flag3 || flag4) {
                System.out.println("El rectangulo con ID = "+id1+" y el rectangulo con ID = "+id2+" se intersectan");
                System.exit(0);
            }
            else{
                System.out.println("Los rectangulos no se intersectan");
            }
        }
    }
}
-----------------------------------------------------
------------------Lab 4 ej3--------------------------
public class ejercicioTres {
    public static void main(String[] args) throws SQLException{
        DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

        Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@colvin.chillan.ubiobio.cl:1521:orcl","juan.ortiz1601","askjzxmnqwpo19");
        Statement stmt = conn.createStatement();

        ResultSet rs = stmt.executeQuery("SELECT nombre, edadAmigo(id) as edad FROM AMIGOS ORDER BY edad");
        while(rs.next()){
            if(rs.getString(1).length()>11) System.out.println(rs.getString(1)+"\t"+rs.getInt(2));
            else System.out.println(rs.getString(1)+"\t\t\t"+rs.getInt(2));
        }
        rs.close();
    }
}
----------------------------------------------------
----------------------edad--------------------------
  CREATE OR REPLACE FUNCTION "JUAN.ORTIZ1601"."EDAD" (id number) RETURN VARCHAR AS
CURSOR edades IS
SELECT * FROM amigos;
elAmigo amigos%ROWTYPE;
fnac_amigo DATE;
actual DATE;
edad NUMBER;
menor NUMBER;
nombre amigos.nombre%type;
BEGIN
        menor := 150;
        SELECT SYSDATE INTO actual FROM DUAL;
        FOR elAmigo in edades LOOP
                edad := (actual-elAmigo.fnac)/365;
                if(edad<=menor) THEN
                menor := edad;
                nombre := elAmigo.nombre;
                end if;
        END LOOP;
        RETURN nombre;
END;
/
-----------------------------------------------------
-------------------edad Amigo------------------------
CREATE OR REPLACE FUNCTION "JUAN.ORTIZ1601"."EDADAMIGO" (idAmigo integer) RETURN INTEGER AS
    edad INTEGER;
    actual DATE;
    fecha amigos.fnac%type;
BEGIN
    SELECT SYSDATE INTO actual FROM DUAL;
    SELECT fnac INTO fecha FROM AMIGOS WHERE id = idAmigo;
    edad := FLOOR((actual-fecha)/365);
    return edad;
END;

/
-----------------------------------------------------
----------------fechamasCercana----------------------
  CREATE OR REPLACE FUNCTION "JUAN.ORTIZ1601"."FECHAMASCERCANA" (id int) RETURN INTEGER AS
    CURSOR AMIGOS IS
    SELECT * FROM AMIGOS;
    elAmigo amigos%ROWTYPE;
    referencia DATE;
    menor NUMBER;
    idAmigo INTEGER;
    auxiliar NUMBER;
BEGIN
    menor := 2000;
    referencia := '31-12-1999';
    FOR elAmigo IN AMIGOS LOOP
        auxiliar := (referencia-elAmigo.fnac)/365;
        if(auxiliar < 0) THEN
            auxiliar := auxiliar*-1;
        end if;
        if(menor>auxiliar) THEN
            idAmigo := elAmigo.id;
            menor := auxiliar;
        END IF;
    END LOOP;
    return idAmigo;
END;
/
---------------------------------------------------
-----------------masJoven--------------------------
CREATE OR REPLACE REPLACE FUNCTION edad() RETURN NUMBER AS
CURSOR edades IS
SELECT * FROM amigos;
elAmigo amigos%ROWTYPE;
fnac_amigo DATE;
now DATE;
edad NUMBER;
menor NUMBER;
BEGIN
    menor := 150;
    SELECT SYSDATE INTO now FROM DUAL;
    FOR elAmigo in edades LOOP
        edad := (now-elAmigo.fnac)/365;
        if(edad<=menor) THEN menor := edad;
        end if;
    END LOOP
    RETURN menor;
END;
---------------------------------------------------
--------------------package body------------------
create or replace PACKAGE BODY PointTools IS

FUNCTION iguales(x INTEGER,y INTEGER,IDP INTEGER)
    RETURN INTEGER IS
    p puntos%rowtype;
BEGIN
    OPEN misPuntos(IDP);
    FETCH misPuntos INTO p;
    IF (x = p.x and y = p.y) THEN
        close misPuntos;
        return 1;
    ElSE
        close misPuntos;
        RETURN 0;
    END IF;
END iguales;

FUNCTION distancia(x INTEGER,y INTEGER,IDP INTEGER)
    RETURN INTEGER IS
    P PUNTOS%ROWTYPE;
    distancia INTEGER;
BEGIN
    OPEN misPuntos(IDP);
    FETCH misPuntos INTO p;
    distancia := SQRT((x-p.x)**2+(y-p.y)**2);
    CLOSE misPuntos;
    RETURN distancia;
END distancia;

FUNCTION enCirculo(x INTEGER,y INTEGER, r NUMBER,IDP INTEGER)
    RETURN INTEGER IS
    p puntos%ROWTYPE;
    distancia NUMBER;
BEGIN
    OPEN misPuntos(IDP);
    FETCH misPuntos INTO p;
    distancia := sqrt((x-p.x)**2+(y-p.y)**2);
    CLOSE misPuntos;
    if(distancia<r) THEN
        RETURN 1;
    END IF;
    RETURN 0;
END enCirculo;
END PointTools;
----------------------------------------------
----------------------Point Tools------------
CREATE OR REPLACE PACKAGE "JUAN.ORTIZ1601"."POINTTOOLS" IS
    CURSOR misPuntos(id puntos.pid%type) is SELECT * FROM PUNTOS WHERE pid = id;
    -- Verificar si dos puntos son iguales
    FUNCTION iguales (x INTEGER, y INTEGER, IDP INTEGER)
    RETURN INTEGER;

    -- CALULAR LA DISTANCIA EUCLÍDEA ENTRE EL PUNTO (x,y) e IDP
    FUNCTION distancia (x INTEGER, Y INTEGER, IDP INTEGER)
    RETURN INTEGER;

    /* Verificar si un punto se encuentra dentro de un circulo
    con centro (x,y) y radio r*/
    FUNCTION enCirculo (x INTEGER, y INTEGER, r NUMBER, IDP INTEGER)
    RETURN INTEGER;
END;
/
---------------------------------------------
----------------Ejercicio profe------------
DECLARE
-- Un ejemplo de cursor explicito
  CURSOR  amg IS
  SELECT * FROM amigos;
  elamigo amigos%ROWTYPE;
  mm20 INTEGER; m2030 INTEGER; m3040 INTEGER; mm40 INTEGER;
  hm20 INTEGER; h2030 INTEGER; h3040 INTEGER; hm40 INTEGER;
  edad  INTEGER;
  FechaSistema DATE;
 BEGIN
  mm20:=0; m2030:=0; m3040:=0;mm40:=0;
  hm20:=0; h2030:=0; h3040:=0;hm40:=0;
-- Fecha del sistema
 SELECT SYSDATE INTO FechaSistema FROM DUAL;
 FOR elamigo in amg LOOP
-- se calcula la edad (en años) de cada amigo
   edad := (FechaSistema - elamigo.fnac) / 365;
-- Mujeres
   IF (elamigo.sexo='F') THEN
    IF edad < 20 THEN mm20 := mm20+1;
      ELSIF edad >= 20 and edad <=30  THEN m2030 := m2030+1;
      ELSIF edad >= 30 and edad <=40  THEN m3040 := m3040+1;
      ELSE mm40 := mm40 +1;
    END IF;
-- Hombres
   ELSE
    IF edad < 20 THEN hm20 := hm20+1;
      ELSIF edad >= 20 and edad <=30  THEN h2030 := h2030+1;
      ELSIF edad >= 30 and edad <=40  THEN h3040 := h3040+1;
      ELSE hm40 := hm40 +1;
    END IF;
  END IF;
 END LOOP;
 -- impresión de la tabla
   dbms_output.put_line( '-----------------Rango de edades ----------'  );
   dbms_output.put_line( '   < 20    [20,30]   [30,40]   >40      Total '   );
   dbms_output.put_line( '--------------------------------------------'  );
   dbms_output.put_line( 'Mj ' || mm20 || '       ' || m2030 || '       ' || m3040 || '      ' || '     ' ||  mm40|| '    ' ||  (mm20+m2030+m3040+mm40));
   dbms_output.put_line( 'Hm ' || hm20 || '       ' || h2030 || '       ' || h3040 || '      ' || '     ' ||  hm40 || '    ' || (hm20+h2030+h3040+hm40));
   dbms_output.put_line( '---------------------------------------------'  );
   dbms_output.put_line( 'Tt ' || (mm20+hm20) || '       ' || (h2030+m2030) || '       ' || (m3040+h3040) || '      ' || '     ' || (mm40+ hm40) || '    ' || (mm20+hm20+m2030+h2030+m3040+h3040+mm40+hm40));
   dbms_output.put_line( '---------------------------------------------'  );
END;
--------------------------------------------------
-----------------------parejaMasCasada------------
set define off;

  CREATE OR REPLACE PROCEDURE "JUAN.ORTIZ1601"."PAREJAMASCASADA" AS
CURSOR losAmigos IS
SELECT * FROM AMIGOS;
elAmigo AMIGOS%ROWTYPE;

CURSOR losCasados IS
SELECT * FROM CASADOS;
elCasado CASADOS%ROWTYPE;

anos INTEGER := 0;
flag boolean := false;
idHombre INTEGER;
idMujer INTEGER;
fechaSistema DATE;
BEGIN
    SELECT SYSDATE INTO fechaSistema FROM DUAL;
    FOR elCasado IN losCasados LOOP
        if(elCasado.fechaSep is null and anos <= (fechaSistema-elCasado.fechaCas)/365) THEN
            anos := (fechaSistema-elCasado.fechaCas)/365;
            idHombre := elCasado.idH;
            idMujer := elCasado.idM;
        ELSIF (anos <= (fechaSistema-elCasado.fechaCas)/365) THEN
            anos := (elCasado.fechaSep-elCasado.fechaCas)/365;
            idHombre := elCasado.idH;
            idMujer := elCasado.idM;
        END IF;
    END LOOP;
    FOR elAmigo IN losAmigos LOOP
        if(elAmigo.id = idHombre or elAmigo.id = idMujer) THEN
            DBMS_OUTPUT.PUT_LINE(elAmigo.nombre);
        END IF;
    END LOOP;
    DBMS_OUTPUT.PUT_LINE('Su matrimonio a durado '||anos||' anos');
end;
/
--------------------------------------------------
----------------------updateMatrimonio------------
CREATE OR REPLACE TRIGGER "JUAN.ORTIZ1601"."UPDATEMATRIMONIO"
    BEFORE UPDATE ON CASADOS
    FOR EACH ROW
     WHEN (OLD.FechaSep is null) DECLARE
    duracion INTEGER;
BEGIN
    duracion := FLOOR((:NEW.FechaSep-:OLD.FechaCas)/365);
    INSERT INTO separacion VALUES(:OLD.IDH,:OLD.IDM,duracion);
end;

/
ALTER TRIGGER "JUAN.ORTIZ1601"."UPDATEMATRIMONIO" ENABLE;
--------------------------------------------------