Xlookup

xlookup - Nachschlagelisten

In Datenbankanwendungen werden häufig Auswahllisten verwendet, in denen der Anwender einen Wert aus einer Menge von Optionen auswählen kann. In der Datenbanktabelle werden dann häufig nur Schlüsselwerte gespeichert, während die Anwendung die Option im Klartext anzeigt.

Im BAF-Framework werden solche Nachschlagelisten in xlookup angelegt, gefüllt und übersetzt.

Liste

Eine Nachschlageliste muss zwingend einen Namen haben, über diesen wird sie im Code adressiert. Damit die Übersicht bei einer Vielzahl von Nachschlagelisten nicht verloren geht, werden die in Kategorien gruppiert. Zur weiteren Erläuterung kann eine Beschreibung ergänzt werden.

Im Abschnitt Einträge kann die Liste mit Einträgen gefüllt werden. Neben einem Schlüssel und einem Wert hat ein Eintrag eine Sortierreihenfolge sowie einen Status. Mit dem Status kann der Datensatz auf inaktiv gesetzt werden, er erscheint dann nicht mehr in der Liste. (Im BAF-Framework werden Datensätze nicht gelöscht, sondern deaktiviert, damit sie und die Historie erhalten bleiben.)

Übersetzung

Jeder Listeneintrag kann in jede der angelegten Sprachen übersetzt werden.

Tabellen

create table data_list (
  data_list_id varchar(40) not null primary key,
  category varchar(40),
  name varchar(40) not null unique,
  description varchar(80),
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)      
);

create table data_list_item (
  data_list_item_id varchar(40) not null primary key,
  data_list_id varchar(40) not null,
  sort int,
  key varchar(40),
  value varchar(80), 
  status int,
  datechg date,
  usrchg varchar(40),
  progchg varchar(40)        
);

create table translate_list_item (
  translate_list_item_id varchar(40) not null primary key,
  data_list_item_id varchar(40) not null,
  translate_language_id varchar(40) not null,
  value varchar(80), 
  datechg date,
  usrchg char(40),
  progchg varchar2(40)      
);

Die Tabelle für die Übersetzungen gehört eigentlich in den Namensbereich translate_ und ist hier nur informativ aufgeführt.

Code

xlookup

#rights  n=frm   r_user=r  r_user.admin=w
#rights  n=admin   r_user.admin=w
#frm   c=xlookup   flt=xlookup_flt   w=320

#btn  y=save   s=#save  se=c
#btn  y=cancel   s=#cancel  se=cp
#btn  y=back   s=#tree_back  se=b
#btn  y=backback   s=#tree_fwd  se=b
#btn  y=export   s=xlookup_eximport(ex)  se=b
#btn  y=import   s=xlookup_eximport(im)  se=b
#btn  c=$T(Add_list)  w=120  s=xlookup_add(list)  se=b

#lbl   c=$T(lookup_filter)   w=160  
#edt   n=edt1   w=135   

#filter

Das Kommando xlookup ist die Definition eines Standard-Formulars. Leserechte für jeden, Schreibrechte für Administratoren.

xlookup_add

~ $EMPTY($FND(s,category))
#tree_add u=root   c=$T(new_list)   t=data_list    c1=name    s="#page_fill  d=xlookup_page_list"   si=Y   

~ $EMPTY($FND(s,data_list_id))
#tree_add u=sel   c=$T(new_list)   t=data_list    c1=name    s="#page_fill  d=xlookup_page_list"   si=Y    f_category=$FND(s,category)

~ $EMPTY($FND(s,data_list_item_id))
#tree_add u=selp   c=$T(new_list)   t=data_list    c1=name    s="#page_fill  d=xlookup_page_list"   si=Y    f_category=$FND(s,category)

~
#tree_add u=selpp   c=$T(new_list)   t=data_list     c1=name   s="#page_fill  d=xlookup_page_list"   si=Y    f_category=$FND(s,category)

~~

Mit xlookup_add wird eine neue Liste angelegt. Je nachdem, wo man sich gerade im Baum befindet, wird dabei Unterschiedliches getan.

Bei der ersten Verzweigung wird keine Kategorie gefunden - es ist also noch kein Eintrag im Baum selektiert. Dann wird der obersten Ebene im Baum (u=root) ein neuer Eintrag hinzugefügt. Bei der zweiten Verzweigung haben wir eine Kategorie (sonst wären wir in der ersten Verzweigung), aber noch keine data_list_id. Wir haben also eine Kategorie selektiert. Unter diese (u=sel) hängen wir nun die neue Liste und setzen gleich die entsprechende Kategorie (f_category=$FND(s,category)) - die der Anwender selbstverständlich abändern kann.

In der dritten Verzweigung haben wir eine Kategorie und eine Liste, aber noch keinen Listeneintrag. Also hängen wir die neue Liste unter den übergeordneten Eintrag des selektierten Eintrags (u=selp - SeletedParent). In der vierten Verzweigung sind wir - mangels Alternativen - auf einem Listeneintrag, also bei den Übersetzungen. Die Kategorie, unter die wir die neue Liste hängen wollen, ist nun zwei Ebenen höher (u=selpp).

xlookup_eximport

~ $ICP(0,ex)
#val_set  n=1  z=$FILEDIALOG(save,$T(filter_baf),baf)
#sql_exporttables   fn=$VAL(1)   t=data_list   t2=data_list_item

~ $ICP(0,im)
#val_set  n=1  z=$FILEDIALOG(open,$T(filter_baf),baf)
#sql_importdefs   t=data_list
#sql_importdefs   t=data_list_item
#sql_importtables   fn=$VAL(1)   t=data_list   t2=data_list_item

~~

Der Ex- und Import der Nachschlagelisten ist ziemliches Standard-Vorgehen. Erwähnenswert mag noch sein, dass die Übersetzungen in xtranslate ex- und importiert werden.

xlookup_flt

#tree_clear 

~ $NEMPTY($EDT(edt1))
#sql select l.*    from data_list l  
#sql    left outer join data_list_item i     on l.data_list_id = i.data_list_id
#sql    left outer join translate_list_item t     on i.data_list_item_id = t.data_list_item_id 
#sql  where upper(l.name) like upper(:kedt)
#sql    or upper(i.cvalue) like upper(:kedt)
#sql    or upper(t.cvalue) like upper(:kedt)
#sql  order by l.name;
#tree_node  u=root     t=data_list     c1=name     s="#page_fill  d=xlookup_page_list"   o=xlookup_open(list)
#tree_fillsql  kedt=$EDT(edt1)%   

~
#sql select *    from data_list     order by category, name;
#tree_node  u=root      k=category  c1=category   nc=Y   s="#page_fill  d=xlookup_page_category"
#tree_node  u=last     t=data_list     c1=name     s="#page_fill  d=xlookup_page_list"   o=xlookup_open(list)  
#tree_fillsql  mex=3

~~

Wenn ein Filter-Begriff in edt1 eingegeben ist, dann wird nach diesem in den Namen der Liste, den Listeneinträgen sowie in den Übersetzungen der Listeneinträge gesucht; letztlich ist das nur ein entsprechendes SQL-Statement, das die Ergebnisse dann im Baum aufführt.

Gibt es keinen Filter-Begriff, werden die Namen aller Listen geladen und diese nach Kategorien gruppiert. Der Baum wird also zunächst in zwei Ebenen gefüllt. Die Listeneinträge werden dann bei Bedarf nachgeladen (o=xlookup_open(list)). Gibt es nicht mehr als drei Kategorien, werden diese gleich geöffnet (mex=3).