Schnell mal eben - allegro-Tricks

nun soll er durch das Dreieck (Code 31) ersetzt werden.

Aber Achtung: wenn der $ irgendwo als solcher vorkommt, dann wird
er ebenfalls ersetzt, denn das Programm kann dies nicht unterscheiden.

Das Durcharbeiten der gesamten Datenbank ist kein großer Trick, es
wird im Text xnext.rtf unter Beispiel 3 beschrieben.

Der erste Trick ist, daß man die lokale Ersetzung mit insert _abc_XYZ_
verwenden muß, denn bei der globalen hat der $ leider die Wirkung
eines Abzwack-Operators: es verschwindet der ganze Rest des Felds.
(s. Handbuch S. 118)

Der zweite Trick ist, mit var k_1 und var k_2 die Felder einzeln
zu bearbeiten, wobei die Feldnummer mitgenommen wird (mit k1/k2
hat man die Feldtexte ohne Nummer), so daß mit
var k_2
...
ins
das Feld wieder korrekt in den Satz zurückgegeben wird.

Der dritte Trick ist, mit if _$_ zu prüfen, ob im Satz wirklich
ein $ vorkommt, denn wenn nicht, braucht ja nichts getan zu werden
und insbes. der Satz nicht wieder gespeichert.

Der vierte Trick ist, daß man mit ^_ (zwei Zeichen) das Dreieck
angeben kann (Strg+_ ist Code 31). Dies gehört zu den Eigenheiten
der lokalen Ersetzung (h xinsert)

Hier die Lösung:

DOLL.FLX : Dollarzeichen ueberall durch das Dreieck ersetzen
2009-11-26

first #
falls der erste Satz gelöscht ist: nächster Satz
if del jump weiter
Jeder Satz wird in dieser Schleife verarbeitet:
:schleife

Kommt $ im Satz vor? Wenn nicht, -> :weiter
if not _$_ jump weiter

*************
var k_1

:loop
Kombination ^ und _ steht fuer das Dreieck:
ins ,$,^_,
ins
var k_2
if not "" jump loop

**************

put   speichern

Nächsten Satz holen (interne Nummernfolge)
:weiter
next #

kein Satz mehr, Ende erreicht
if cancel jump exit
der Satz ist gelöscht
if del jump weiter

es gab noch einen Satz? dann -> :schleife
if yes jump schleife

:exit
end

Statt des Abschnitts zwischen ***** geht auch, kürzer:

var kn
ins ,$,^_,
ins
put

Das wäre der fünfte Trick: mit var kn wird der gesamte Satz in die iV kopiert
die Ersetzung darin durchgeführt und das Ganze wieder in den Arbeitsspeicher
zurückkopiert.

(2009-11-26)
---------------------------------------------------------------------------------------------------

Trick 75: Index ändern on-the-fly
            Bestimmte Einträge im laufenden Betrieb ändern

Aufgabe: Schnell mal eben für eine Anzahl von Sätzen einen bestimmten
            Registereintrag ändern.

Warum das?
Wer kennt es nicht: Man macht an den Indexparametern eine ganz kleine
Änderung, aber a99 ist zu dumm, dann schnell mal eben die nicht mehr
korrekten Schlüssel automatisch rauszusuchen und -zuwerfen und die
nunmehr korrekten einzusortieren.
Warum das so ist? Nun, a99 kriegt einfach gar nicht mit, daß man was
geändert hat - es prüft nicht ständig, ob die Datei noch so ist wie
vorher - und falls nicht, dann genau das Richtige zu tun. Das wäre
leider zuviel verlangt, man muß also selber dran denken, daß man den
Index dann erneuert.
Ha! Index erneuern, das ist bei Kleinbanken kein Problem, aber bei
sehr großen braucht's massig Zeit und ist im Netz auch nur dann
möglich, wenn gerade keiner an der Datenbank arbeitet, und das kann
schon ein arges Ärgernis sein; in einem 24/7-Betrieb geht das gar
nicht!

Aber FLEX birgt das Potential für einen pfiffigen Trick, und der geht so:

Zuerst die Ergebnismenge aller Sätze bilden, bei denen die
Änderung sich auswirken würde.
Dann einen FLEX schreiben, der
a) aus einem Satz den nicht mehr gültigen Schlüssel bildet und
   diesen löscht (mit ixdel ...)
b) aus demselben Satz den nunmehr gültigen Schlüssel bildet und
   diesen einfügt (mit ixadd ...)

Es folgt das Kochrezept, an das man sich in jedem Fall halten kann.
(Doku zu den zwei Befehlen: h xixadd. Darin auch Hinweis auf einen
aufwendigeren FLEX umindex.flx, der sich empfiehlt, wenn besonders
viele Schlüssel zu ändern sind; darauf wurde auch in der Vb.202
schon kurz aufmerksam gemacht. Er löscht zunächst *alle* Schlüssel
eines Satzes nach Maßgabe der alten Parameter und speist dann alle
nach Vorschrift der neuen neu ein. Je nach Menge dauert das viel
länger. umindex.flx ist im Gesamtpaket mit drin.)

// Ergebnismenge der relevanten Sätze vorher bilden

first
:loop
// den alten, nicht mehr korrekten Schl. bilden
// und zwar mit Index-Präfix, z.B |7, ohne Spatium dahinter
var "|..." ...
ins #uzA
var i " " #uzA
ixdel

// den neuen, jetzt korrekten Schl. bilden
var "|..." ...
ins #uzN
var i " " #uzN
ixadd

:nxt
next
if yes jump loop
mes ERLEDIGT!

Statt var "..." ... ist natürlich jeweils ein geeigneter Algorithmus
für den betr. Schlüssel einzusetzen. Dazu sind evtl. mehrere Befehle
nötig. Insbes. kann man mit xcode ip oder xcode iq die Umcodierung
der Indexparameter mit heranziehen.

Auch umgekehrt, zuerst neu dann alt, ist es möglich. Oder wahlweise nur
den alten, nicht mehr benötigten Schlüssel löschen oder nur den neuen,
den es bisher noch nicht gab, erzeugen.

Ferner ist es natürlich auch möglich, statt nur eines Schlüssels gleich
mehrere zu löschen und/oder neu einzuspeisen; dann erweitert man eben
die Sache um entsprechende Abschnitte. Ratsam ist natürlich immer, es
erst mit einer kleinen Erg.Menge zu testen...

Aber was, wenn man auf keine Weise die Ergebnismenge aller betroffenen
Sätze bilden kann? Dann erweitert man die Schleife mit first # und
next # eben auf die Gesamtbank und startet es vor der Mittagspause.
Aber Achtung: Statt einfach nur next # muß es dann so lauten:

:nxt
next #
if deleted jump nxt
if not cancel jump loop

denn es könnte sich bei dem mit next # geladen Satz um einen
gelöschten handeln ("deleted"), so einer ist zu überspringen.

(2010-05-04)

---------------------------------------------------------------------------------------------------

Trick 76: Erweiterter Aktionsradius
            Ergebnismenge einschl. verknüpfter Sätze durcharbeiten

Aufgabe: Schnell mal eben eine Ergebnismenge durcharbeiten, wobei aber
zu jedem Satz auch die mit ihm in bestimmter Weise verknüpften Sätze
mit verarbeitet werden sollen, aber nicht unbedingt in derselben Weise
wie der Hauptsatz.

Warum das?
Beispiele sind nicht nur die verknüpften Bandsätze, sondern auch Exemplar- oder Bestellsätze
oder die Ausleihen von Nutzern etc., d.h. alles kommt in Betracht, was durch die Indexierung
miteinander zusammenhängt.
Ferner: Es soll ein reines FLEX-Verfahren sein, also ohne Exportparameter, bis auf Umcodierung.
Und: Das Verfahren soll mit a99 und mit acon funktionieren.

Option: Vielleicht will man auch gelegentlich schnell mal eben die
Gesamtbank entsprechend abarbeiten ...

Beisp.1: Erg.Menge exportieren, aber unter jedem Satz die Exemplardaten
         auflisten.

Beisp.2: In jedem Satz der Erg.Menge bestimmte Änderungen vornehmen,
         zusätzlich aber auch in den verknüpften Untersätzen.

Gesucht ist eine allgemeine Lösung, die in allen vergleichbaren
Fällen zum Einsatz kommen kann! Ein FLEX-Unterprogramm also, aber mit
Variationsmöglichkeiten.

Man konnte solche Produktionen seit langem mittels der "Nachladung"
in den Exportparametern bewerkstelligen. Nun aber soll eine Methode
gefunden werden, die allein mit FLEX arbeitet, denn die Export-
Parametrierung ist eine wegen ihrer Abstraktheit und Kryptik doch recht
schwierig anzuwendende Sache.

Der Lösungsweg

Folgende Kurzbezeichnungen sind sinnvoll:
   HM = Hauptergebnismenge
   ZM = Zusatz-Erg.Menge, jeweils zu einem Satz der HM zu bilden
        (Manchmal ist sie leer!)

Zwei Probleme stellen sich in den Weg:

Problem 1:
Wir können nicht die übliche Methode first / next verwenden, denn zu
jedem Satz ist eine Zusatz-Erg.Menge (ZM) zu bilden - dadurch wird
dann die HM geschlossen. Nach Verarb. der ZM ist zur HM zurückzukehren
und in dieser dann zum nächsten Satz zu gehen. Das ginge in a99, in
acon aber nicht! [Evtl. wird das noch geändert!]
Lösung: Aus der HM wird mittels des Befehls
           var i,
        eine Nummernliste erstellt, in der die internen Satznummern
        durch ',' getrennt vorliegen
        Aber ACHTUNG: Die Liste wird in einer $-Var. gespeichert, das
        beschränkt die Größe der Erg.Menge auf etwa 8-10000. Will man
        größere erschlagen können, muß man die Methodik umstellen
        auf Speicherung in einer Datei und dann zeilenweises Einlesen.

Problem 2: Die folgenden drei je spezifischen Aktionen können
nicht Teil des erwünschten, allgemeingültigen Unterprogramms sein:

ZMget : Bildung der zu einem HM-Satz gehörigen ZM
HMact : Ausführung der gewünschten Aktion am HM-Satz
ZMact : ... am verknüpften ZM-Satz

Lösung: Unser Unterprogramm soll EXTACT heißen, d.h. es beginnt mit
der Zeile :EXTACT und endet mit return. (Der Name leitet sich ab
von "extended action", wie man die Sache auch bezeichnen könnte.)
Das Unterprogramm enthält nicht selber die drei Aktionen, sondern
die liegen als Unterprogramme "weiter oben" im Haupt-FLEX, unter den
o.g. Namen, denn sie müssen spezifisch für die jeweilige konkrete
Aufgabe sein.
Weil aber verschachtelte Unterprogramme nicht möglich sind, müssen
die drei Unterprogramme mit "jump ..." aufgerufen werden, d.h. sie
sind keine echten Unterprogramme, sondern werden jeweils mit einem
"jump ..." beendet, der zurück in das Unterprogramm EXTACT hinter den
jeweiligen Aufruf führt: :HMact endet mit jump HMactRet und führt
damit zu :HMactRet unter jump HMact, usw.

Was ist zu tun?

Im Haupt-FLEX sieht der Ablauf so aus:
und hier muß man die "AKTIONen" selber geeignet programmieren!,
d.h. NUR das hier, zwischen ANFANG und ENDE, ist der variable Teil,
den man in den eigenen FLEX bzw. Job einbauen muss:

(Also das folgende Muster kopieren und geeignet modifizieren!)

// *** ANFANG des eigenen .flx oder .job ************************
// ... Vorbereitende AKTIONen ...

// Fuer acon:
var m
if %ac-% echo off

// Wenn Gesamtbank gewuenscht, dann Flag $gF setzen:
// $gF=1

// Sonst muss jetzt eine Erg.Menge vorliegen, evtl. geordnet.

exp f <dateiname>   // Ausgabedatei oeffnen
exp p utf   // diese 2 Zeilen nur für Wandlung von ASCII nach UTF-8
exp wA      // Bei #-A in utf.apr wird der zu schreibende Text umcodiert

// der Aufruf des Unterprogramms:
perform EXTACT
mes Erledigt!

// ... nachbereitende Aktionen des Hauptteils ...

end

// An das Ende des eigenen Jobs kommt noch dieser Teil,
// ebenfalls selbst zu schreiben, weil spezifisch.

// ###############
// Diese drei Abschnitte sind aufgabenspezifisch auszufuellen:

// 1. Bildung der Sub-Erg.Menge ZM
:ZMfind
// *** hier AKTION zur Bildung der ZM-Erg.Menge, evtl. mit Ordnung ***
// i.d.R. mit "var ..." einen Suchbefehl machen und dann "find"
// zurueck in das UP
jump ZMfindRet

// 2. Verarb. d. Satzes aus der HM (ist jetzt der aktive Satz)
:HMact
// *** hier AKTIONen mit dem HM-Satz ***
// evtl. bestimmte Sätze ausschließen, z.B. mit
// if not #20 jump HMnext
// i.d.R. mit "write ..." die Ausgabe erzeugen
jump HMactRet

// 3. Export des aktuellen Satzes der ZM (ist jetzt aktiver Satz)
:ZMact
// *** hier AKTIONen mit dem ZM-Satz ***
// i.d.R. mit "write ..." die Ausgabe erzeugen
jump ZMactRet

// ################

// jetzt noch die Datei hinzunehmen, in der :EXTACT ist:
include extact.inc

// *** ENDE des eigenen FLEXjobs *********************************

================ extact.inc =====================================

==>Mit X getfile extact.inc können Sie sich die Datei holen!
oder von hier kopieren:

// *** Beginn extact.inc *****************************************
// Label fuer den Aufruf mit perform EXTACT zur Anwendung auf die
// aktuelle Erg.Menge, die in der vorliegenden Reihenfolge
// abgearbeitet werden soll

:EXTACT
// Die internen Nummern der HM in $hm ablegen, mit , getrennt
var i,
ins $hm
// Diese Liste wird dann abgearbeitet von vorn nach hinten
// ACHTUNG: die Erg.Menge kann fuer diese Methode nicht groesser als
// 8-10.000 Saetze sein.

// Wenn $gF besetzt, dann Gesamtbank abarb.

if $gF first #;if del jump HMgesamt

:HMloop
// die erste (bzw. naechste) Nummer nehmen, # davorsetzen
// ($hm beginnt mit dieser Nr.)
// und den HM-Satz mit dieser Nr. laden
// - falls nicht $gF gesetzt, dann ist jetzt naechste Satz schon da
if not $gF var "#" $hm (e",");f1nd

// Die HM-Aktion ausfuehren
jump HMact

:HMactRet
// Zu dem Satz nun die zusaetzliche Menge (ZM) bilden
// Vorher Objekt 2 einschalten - damit dann next # klappt
// aber 1 nach 2 kopieren, damit unter :ZMfind zugaenglich
copy obj 1 2
set obj 2
// d.h. die ZM-Saetze werden in Obj.2 geladen
jump ZMfind
// (von dort Ruecksprung mit jump ZMfindRet)
:ZMfindRet
// "less than 1"? d.h. ZM ist leer
if l1 set obj 1;jump HMnext

// Die ZM ist nicht leer, also abarbeiten

first
:ZMloop
// die ZM-Aktion :ZMact ausfuehren (im HauptFLEX)
jump ZMact
// von dort zurueck mit jump ZMactRet
:ZMactRet
// naechsten Satz der ZM
next
if yes jump ZMloop
// keiner mehr da - Die ZM schliessen und loeschen
close res
// ZM Ende, jetzt wieder Objekt 1
set obj 1

// Hauptschleife geht weiter, momentan erste Nr. der HM wegnehmen
:HMnext
// Wenn Gesamtbank:
if $gF jump HMgesamt

// Naechsten Satz der Erg.Menge
var $hm (b",")
// verkuerzte Liste wieder in $hm
ins $hm
// Ist noch was da? Dann weiter in Hauptschleife mit dem naechsten Satz
if $hm jump HMloop
jump HMend

// naechsten Satz der Gesamtbank, etwas schwierig wg. unbesetzter Nummern etc.
:HMgesamt
next #
// Ende? (a99: cancel, acon: no)
if no jump HMend
if cancel jump HMend

if del jump HMgesamt
jump HMloop

:HMend
return
end
// **** ENDE extact.inc *****************************************

Es wurden uns ein paar Verbesserungswünsche mitgeteilt, die wir
noch umsetzen konnten.

Geben Sie zuerst in a99 diese zwei Befehle:

X getfile extact.ini
     das ist die eigentliche Funktion :EXTACT,
     diese Datei erfordert *keinen* Eingriff

X getfile extact.flx
     das ist ein Muster zum Abwandeln! Darin wird :EXTACT aufgerufen
     Ausführliche Hinweise stehen drin.

Dann haben Sie die zwei Dateien in Ihrem FLEX-Ordner.

Um ein *eigenes Projekt* zu realisieren, so vorgehen:

1. Kopie von extact.flx machen, sagen wir mypro.flx

2. mypro.flx bearbeiten: (darin ist alles kommentiert)

   A. Drei Flags setzen, und zwar für diese Optionen:
      $gF : Erg.Menge oder Gesamtbank verarbeiten
      $mF : Hauptsatzdaten immer ausgeben,
             oder nur wenn Unterdaten existieren?
      $hF : Hauptsatz über oder unter den Untersätzen auswerfen

   B. Drei Funktionen ergänzen:
      :ZMfind: Funktion für das Bilden der Zusatz-Erg.Menge
      :HMact : Aktion für den jeweiligen Hauptsatz
      :ZMact : Aktion für die zusätzlichen (nachgladenen) Sätze

Die Aktionen werden zumeist write-Befehle sein, um die erwünschten
Datenelemente in der erwünschten Form auszugeben, es können aber auch
andere Aktionen sein, die man mit den Datensätzen durchführen will,
also auch Änderungen an Haupt- bzw. Nachladesätzen.
Weitere Tips in den Dateien.

3. Vor dem Start: Mit Export / Andere Exportdatei
    in a99 einen Dateinamen fuer den Output vorgeben!

4. Schließlich mit   X mypro   starten!

(Solange kein "put"-Befehl vorkommt, kann nix schiefgehen.)

Trick 77: RAK = Register-Abschnitts-Kopie
            Reg.Abschnitt in eine andere Indexdatei kopieren

Aufgabe: Schnell mal eben einen Registerabschnitt kopieren von einem
Index (z.B. .adx) in einen anderen (z.B. .aex).

Warum das?
Konkreter Anlaß war die Beobachtung, daß die Expansion einer
Suche nicht klappt, wenn das ALL-Register benutzt wird. Z.B. würde
man mit find all &schiller die Räuber nicht erwischen, wenn sie
(d.h. das Wort "raeuber") in Unterdatensätzen vorkommen, die den
Namen "Schiller" nicht enthalten.
Das kommt, weil das ALL-Register im Index .aex liegt, das Expansions-
Register aber in .adx: Das sind dort die Eintraege, die mit | beginnen
im Register 10.
Ob und wann diese Unzulänglichkeit behebbar sein wird, das steht noch
abzuwarten. Immerhin sind fast 4 Jahre verstrichen, seitdem das ALL-
Register entwickelt wurde, und erst jetzt fiel das Problem auf.

Was aber, so die Idee zum Trick, wenn das Expansionsregister einfach
irgendwie in .aex rüberkopiert werden könnte? Dann möcht's doch
gehen!? Ja, das tut es!
Das ist zwar nett, aber natürlich wird der Einwand sofort kommen:

Alsbald nach solchem Kopieren können sich schon wieder Einträge ändern!
Neue kommen hinzu, andere verschwinden. Und schon ist die Expansion
unzuverlässig - das ist schlimmer, als wenn's sie gar nicht gibt.
Richtig. Der Trick ist ein Behelf, mehr nicht. Aber was jahrelang gar
nicht auffiel, mag wohl damit erst einmal ein paar Wochen hingehen,
wenn man den Vorgang angemessen häufig wiederholt, vielleicht täglich
oder alle paar Stunden.

Das konkrete Beispiel soll deshalb mehr zur Veranschaulichung der
Methode dienen, nicht als wirkliche Lösung dieses speziellen Problems.
(FLEXperten seien angespornt, die Sache noch zu erweitern um eine
Routine, die zuerst aus .aex die bereits vorhandene Kopie des
Abschnitts wieder löscht, bevor der aktuelle Stand hineinkopiert wird.
Denn sonst bleiben Einträge stehen, die nicht mehr stimmen. Schön
wär's, man könnte das auch mit acon machen - das geht aber nicht,
weil acon den Modus f3 von qrix nicht kennt. Man müßte f1 nehmen
und die Prozedur etwas umständlicher umschreiben.)

Es folgt nun der FLEX trix.flx, der den Transfer des Expansions-
registers aus .adx nach .aex leistet. Man startet ihn in a99 mit
dem Aufruf X trix.

---------------------------------------------------

trix.flx : "transfer index" : SR-Register von .adx in .aex kopieren
2014-09-12
Verallgemeinerbar: Registerabschnitt in einen anderen Index kopieren
(wozu auch immer)

SR-Eintraege aus .adx in Datei trix.dat schreiben

open x trix.dat
Modus 3 fuer qrix einstellen und Separator --- für Von/Bis-Suche
qri f3
qri d---
Den Abschnitt in die Datei schreiben
Qri |: |0---|z
close x

Datei trix.dat dann zeilenweise einlesen und in .aex einfuegen.
Die Dateizeilen haben die Form ih||iu, wobei ih die Nummer des
Datensatzes ist, in dem "Schiller" steht, iu diejenige eines
Untersatzes, in dem "Räuber" steht.

open trix.dat
zur Sicherheit
set tbl lock

:srloop
Zeile lesen
get
Dateiende
if cancel jump ende

ins $q

Zeile zerlegen : aus ih||iu soll ih ~e:|iu werden

var $q (e"|")
ins $n
var $q (b"|")
ins $q

Zeile erstellen und einfuegen
var $n " ~e:" $q
ixadd
Schleife
jump srloop

:ende
flush index
close index
set tbl fre

close
del trix.dat
mes Done

allegro-C

Schnell mal eben ...

Trick 17 - 77