Hermetyzacja w PROGRESS-ie.

["Bogdan Brzozowski" <bogdan@novum.pl>]

Bogdan Brzozowski wrote:
>         Można to osiągnąć
>         poprzez stworzenie instancji procedury zewnętrznej
>         poleceniem RUN PERSISTENT, a następnie używając procedur
>         wewnętrznych [ciach] Jest to rzeczywiście
>         proteza. Program tak napisany będzie działał ok. 2,5 raza
>         wolniej przy wielokrotnym tworzeniu i niszczeniu instancji
>         procedury zewnętrznej, niż program który takiej instancji
>         nie tworzy [ciach]


Tomasz Judycki odpowiedział:
	Przeciez procedury persistent nie zostaly po to wymyslone!
	Procedure uruchamia sie raz w trybie persistent przy uruchomieniu
aplikacji i dzieki temu ma sie stale w pamieci operacyjnej dostepne
procedury wewnetrzne. A przy zakonczeniu dzialania aplikacji
	likwidujemy instancje procedury. Takie podejscie bedzie
	szybsze niz wielokrotne uruchamianie procedury
	z pliku zewnetrznego.

Panie Tomaszu,
	Problem przedstawiłem bardzo pobieżnie. Teraz go sprecyzuję.
	Chodziło mi o próbę obiektowego podejścia do pisania
	transakcji w PROGRESS-ie. Procedura zewnętrzna miała
	pełnić rolę klasy. Zmienne zadeklarowane w jej bloku
	głównym - rolę prywatnych atrybutów tej klasy, natomiast
	procedury wewnętrzne - rolę metod. Jeżeli metodami takiej
	"klasy" chciałbym przetwarzać dużą ilość rekordów i nie
	likwidowałbym instancji "obiektów - procedur zewn."
	(czyli instancji moich "klas"),  wówczas miałbym pamięć
	zajętą setkimi lub tysiącami niepotrzebnych mi już instancji.
	Przeprowadzony przeze mnie test polegał na wywołaniu po
	5 000 razy różnych metod: fnd, ins, upd  wewnątrz
	instancji "procedury-klasy", którą zamieszczę poniżej
	(i jeżeli starczy Panu cierpliwości - proszę na nią spojrzeć).
	Tabela tymczasowa ttTbl służy do przekazywania parametrów
	pomiędzy metodami "klasy" a zewnętrznymi procedurami
	tworzącymi i niszczącymi instancje klasy. Takie podejście
	musiałem odrzucić ze względu na wydajność (ok. 2,5 raza gorszą,
	niż w przypadku wywoływania "zwykłych" procedur
	zewnętrznych realizujących to samo, co metody: fnd,
	ins, upd). Trochę tego żałuję, ponieważ dzięki tak
	uzyskanej hermetyzacji miałbym w sposób bardziej
	naturalny zapewnioną częściową zgodność pomiędzy kodem
	źródłowym i projektem aplikacji stworzonym za pomocą
	standardu projektowania obiektowego, jakim jest UML.
	Jeżeli w przedstawionym przeze mnie podejściu popełniłem
	jakieś błędy, lub Pan i inni korespodenci listy macie pomysły,
	aby jednak taką hermetyzację uzyskać (bez utraty wydajności)
	- jestem tym bardzo zainteresowany.
	Zgadzam się z Panem Tomaszem, że polecenie run persistent
	daje inne, cenne możliwości.

	Pozdrawiam

	Bogdan Brzozowski


/* pseudoklasa w formie
   proc. zewn. a_tbl.p */

/* atrybuty klasy-tabeli */
def buffer bA_tbl for a_tbl.

/* do komunikacji z inerfejsem uzytkownika */
def temp-table ttTbl like a_tbl.

/* szukaj rekordu */
procedure fnd:
    def input param iiKeyForFind as int no-undo.
    def param buffer bttTblp for ttTbl.
    def var vcRetp as char init "NOT-OK".

    proc:
    do  on error undo, leave proc
        on stop undo, leave proc:

        case iiKeyForFind:
            when 0 then
                find bA_tbl
                where bA_tbl.tbl_id = bttTblp.tbl_id no-error.

            when 1 then
                find bA_tbl
                where bA_tbl.tbl_name = bttTblp.tbl_name no-error.
        end case.
        if locked(bA_tbl) then
            undo, leave proc.

        if not available(bA_tbl) then
            undo, leave proc.

        vcRetp = "OK".
    end.
    return vcRetp.
end procedure.

/* dopisz nowy rekord */
procedure ins:
    def param buffer bttTblp for ttTbl.
    def var vcRetp as char init "NOT-OK".

    proc:
    do  on error undo, leave proc
        on stop undo, leave proc:
        create bA_tbl.

        run upd(buffer bttTblp).
        if return-value <> "OK" then
            undo, leave proc.

        vcRetp = "OK".
    end.
    return vcRetp.
end procedure.

/* zapis do istniejacego rekordu */
procedure upd:
    def param buffer bttTblp for ttTbl.
    def var vcRetp as char init "NOT-OK".

    proc:
    do  on error undo, leave proc
        on stop undo, leave proc:
        if not available(bA_tbl) then do:
            run fnd(input 0,
                    buffer bttTblp) .
            if return-value <> "OK" then
                undo, leave proc.
        end.

        bA_tbl.tbl_name =  bttTblp.tbl_name.

        vcRetp = "OK".
    end.
    return vcRetp.
end procedure.


/* usun rekord */
procedure kill:
    def param buffer bttTblp for ttTbl.
    def var vcRetp as char init "NOT-OK".

    proc:
    do  on error undo, leave proc
        on stop undo, leave proc:
        if not available(bA_tbl) then do:
            run fnd(input 0,
                    buffer bttTblp) .
            if return-value <> "OK" then
                undo, leave proc.
        end.

        delete bA_tbl.

        vcRetp = "OK".
    end.
    return vcRetp.
end procedure.


/* zwroc rekord  w tabeli tymczasowej */
procedure ret :
    def param buffer bttTblp for ttTbl.
    def var vcRetp as char init "NOT-OK".

    proc:
    do  on error undo, leave proc
        on stop undo, leave proc:
        if not available(bA_tbl) then do:
            run fnd(input 0,
                    buffer bttTblp) .
            if return-value <> "OK" then
                undo, leave proc.
        end.

        buffer-copy bA_tbl to bttTblp.

        vcRetp = "OK".
    end.
    return vcRetp.

end procedure.



------
Strona WWW:     http://pluton.pol.lublin.pl/pugpl/index.htm
Obsluga listy:  listserv@zeto.bydgoszcz.pl
Archiwum listy: http://www.zeto.bydgoszcz.pl/progress/index.html
------