-- Funktionen um Personen zu verwalten --
-- [
create function "chk_person" (varchar(10),text,text,text,text,
                              varchar(10),varchar(10),varchar(10),varchar(50),
                              varchar(50), varchar(100))
    returns int4 as '
        /* 
         * chk_person(anrede, titel, nachname, vorname, geb_dat,
         *            postfach, telefon, fax, handy,
         *            email, webpage)
         *
         * ueberpruefen ob die Person schon in der DB gespeichert ist.
         *
         * returns: -1: falsche Parameter
         *          -2: Inkonsistenz endeckt. Es existiert bereits eine
         *              Person mit dem einer, aber nicht alle der Parameter 
         *              übereinstimmen
         *          0: Person existiert noch nicht in der DB
         *          >0: Person existiert bereits, gibt id_person zurück.
         */

        DECLARE
            idp person.person%ROWTYPE;
        BEGIN
            IF $3 IS NULL OR $3 = '''' OR
               $4 IS NULL OR $4 = '''' OR
               $5 IS NULL OR $5 = '''' THEN
                RETURN -1;
            END IF;

            select INTO idp * from person.person where
                nachname = $3 and vorname = $4 and
                geb_dat = $5::date;

            IF NOT FOUND THEN
                RETURN 0;
            ELSE
                IF idp.anrede <> $1 OR idp.titel <> $2 OR
                   idp.postfach <> $6 OR idp.telefon <> $7 OR
                   idp.fax <> $8 OR idp.handy <> $9 OR
                   idp.email <> $10 OR idp.webpage <> $11 THEN
                    RETURN -2;
                END IF;
            END IF;

            RETURN idp._id_;
        END;
    ' language 'plpgsql';

create function "ins_person" (varchar(10),text,text,text,text,
                              varchar(10),varchar(10),varchar(10),varchar(50),
                              varchar(50),varchar(100))
    returns int4 as '
        /* 
         * ins_person(anrede, titel, nachname, vorname, geb_dat,
         *            postfach, telefon, fax, handy,
         *            email, webpage)
         *
         * fügt eine Person in die DB ein sofern es nicht schon existiert,
         * inkonsistenzen erzeugt wuerden, oder die Eingabedaten fehlerhast
         * sind.
         *
         * returns: 0: wenn die Person nicht eingefuegt werden kann
         *          >0: wenn die Person eingefuegt werden konnte oder bereits
         *              existierte, gibt id_person zurück.
         */

        DECLARE
            idp person.person._id_%TYPE;
        BEGIN
            select INTO idp person.chk_person($1,$2,$3,$4,$5,$6,$7,$8,$9,
                                              $10,$11);

            IF idp < 0 THEN
                RETURN 0;
            ELSE
                IF idp = 0 THEN
                    insert into person.person (anrede,titel,nachname,vorname,
                                               geb_dat,postfach,telefon,fax,
                                               handy,email,webpage)
                        values ($1,$2,$3,$4,$5::date,$6,$7,$8,$9,$10,$11);

                    select INTO idp person.chk_person($1,$2,$3,$4,$5,$6,
                                                      $7,$8,$9,$10,$11);
                END IF;
            END IF;

            RETURN idp;
        END;
    ' language 'plpgsql';
    
create function "ins_person" (varchar(10),text,text,text,text,
                              varchar(10),varchar(10),varchar(10),varchar(50),
                              varchar(50),varchar(100),int4)
    returns int4 as '
        /* 
         * ins_person(anrede, titel, nachname, vorname, geb_dat,
         *            postfach, telefon, fax, handy,
         *            email, webpage, id_adresse, id_abteilung)
         *
         * fügt eine Person in die DB ein sofern es nicht schon existiert,
         * inkonsistenzen erzeugt wuerden, oder die Eingabedaten fehlerhast
         * sind.
         * Außerdem werden schon zuordnugen zu einer Adresse und einem Arbeits
         * platz gemacht.
         *
         * returns: 0: wenn die Person nicht eingefuegt werden kann
         *          >0: wenn die Person eingefuegt werden konnte oder bereits
         *              existierte, gibt id_person zurück.
         */

        DECLARE
            idp person.person._id_%TYPE;
        BEGIN
            select INTO idp person.ins_person($1,$2,$3,$4,$5,$6,$7,$8,$9,
                                              $10,$11);

            IF idp = 0 THEN
                RETURN 0;
            ELSE
                PERFORM person.person_adresse(idp, $12);
                /* 
                 * Die Zuordnung zu arbeit erfordert weiter Informationen,
                 * wie Gehalt, Position u.a. darum ist eine Zuordnung hier
                 * warscheinlich nicht seht sinnvoll. Trotzdem lasse ich das
                 * hier nochmal auskommentiert stehen, vielleicht braucht man
                 * es ja doch...
                 */
                --select INTO tmp create_rel_person_abteilung(idp, $13);--
            END IF;

            RETURN idp;
        END;
    ' language 'plpgsql';

create function "person_adresse" (int4, int4)
    returns int4 as '
        /*
         * person_adresse(id_person, id_adresse)
         *
         * ordnet eine Person einer Adresse zu, dies passiert ueber einen
         * Eintrag in der Relation wohnt. Es wird sichergestellt das keine
         * inkonstistenzen auftreten (keine doppelten Zuordnungen)
         *
         * returns: -1: Wenn die Eingabedaten fehlerhaft waren.
         *          0: Wenn die Zuordnung nicht gemacht werden konnte.
         *          1: Wenn die Zuordnung gemacht wurde.
         */

        BEGIN
            IF $1 IS NULL OR $1 < 1 OR
               $2 IS NULL OR $2 < 1 THEN
                RETURN -1;
            END IF;

            PERFORM * from person.person where _id_ = $1;
            IF NOT FOUND THEN
                RETURN 0;
            END IF;

            PERFORM * from adresse.adresse where _id_ = $2;
            IF NOT FOUND THEN
                RETURN 0;
            END IF;

            PERFORM * from person.wohnt where 
                id_person = $1 and id_adresse = $2;
            IF NOT FOUND THEN
                insert into person.wohnt (id_person, id_adresse) 
                    values ($1, $2);
                IF NOT FOUND THEN
                    RETURN 0;
                END IF;
            END IF;

            RETURN 1;
        END;
    ' language 'plpgsql';

-- Da kann ich keinen view draus machen, da ich einen Parameter brauche.
create function "person_wohnt" (int4)
    returns SETOF wohnt as '
        /*
         * person_wohnt(id_person)
         *
         * ordnet eine Person einer Adresse zu, dies passiert ueber einen
         * Eintrag in der Relation wohnt. Es wird sichergestellt das keine
         * inkonstistenzen auftreten (keine doppelten Zuordnungen)
         * Wird fuer id_adresse NULL oder ein Wert < 1 eingegeben, so sucht
         * die Funktion nach den Ein
         *
         * Das ist im prinziep das selbe wie 
         * select * from wohnt where id_person=??
         * ich lass es trotzdem zu anschauungszwecken drin.
         *
         * returns: -1 (in erstem Element): Wenn die Eingabedaten fehlerhaft 
         *                                  waren.
         *          0 (im ersten Element): Die Person existiert nicht
         *          >0 (in allen Elementen): Jede Adresse (id_adresse) an der 
         *                                   die Person wohnt.
         *          <EMPTY SET>: Keine Adresse gefunden.
         */

        DECLARE
            idw_curs refcursor;
            idw person.wohnt%ROWTYPE;
        BEGIN
            IF $1 IS NULL OR $1 < 1 THEN
                idw.id_person := -1;
                idw.id_adresse := -1;
                RETURN NEXT idw;
                RETURN;
            END IF;

            PERFORM * from person.person where id_person = $1;
            IF NOT FOUND THEN
                idw.id_person := 0;
                idw.id_adresse := 0;
                RETURN NEXT idw;
                RETURN;
            END IF;

            /* 
             * Moeglichkeit 1
             *
             * OPEN idw_curs FOR select * from person.wohnt where id_person = $1;
             *
             * FETCH idw_curs INTO idw;
             * WHILE FOUND LOOP
             *     RETURN NEXT idw;
             *     FETCH idw_curs INTO idw;
             * END LOOP; 
             */

            /* 
             * Moeglichkeit 2
             */
            FOR idw IN select * from person.wohnt where id_person = $1 LOOP
                RETURN NEXT idw;
            END LOOP;

            RETURN;
        END;
    ' language 'plpgsql';

create function "id_person" (text, text, text)
    returns int4 as '
        /* 
         * get_id_person_by_ukey1(nachname, vorname, geb_dat)
         *
         * Ermittelt die id (id_person) einer in der DB enthaltenen Person 
         * anhand des Primaerschluessels (nachname, vorname, geb_dat) 
         *
         * returns: 0: wenn die Person nicht eingefuegt werden kann
         *          >0: wenn die Person gefunden wurde, gibt id_person zurück.
         */

        DECLARE
            idp person.person._id_%TYPE;
        BEGIN
            select INTO idp _id_ from person.person where
                nachname = $1 and vorname = $2 and geb_dat = $3::date;

            IF NOT FOUND THEN
                RETURN 0;
            ELSE
                RETURN idp;
            END IF;
        END;
    ' language 'plpgsql';
-- ]
-- Ende Personendaten --