Inf / WshDis

wsh: Diskussion, Ideen, Fehler, History

todo

  • complexe DatenStruktur wie in tut05
  • systematische Test entlang syntax ==> aus WshTutSyn

clean sql query

  • query fetch* close
  • update
  • execute (moreResults fetch* close)* {c} nur moreResults is sequentiel, die fetch von verschiedene resultsets können parallel laufen
  • header auch mit Spezialzeichen

Orthogonal

  • input simpe String ⇒ from pipe
  • fetchVars from/to class ⇒ fetchVars ⇒ gemäss sqlDA
  • format according to sqlDa (how do we get cx?)
  • output by fetch ⇒ to pipe mit oMutate ⇒ sqlFTab ⇒ autoTab
  • dynamisch ⇒ prepared

java api

  • execute simple querymit genau 1 resultset
    1. query: cx, src, retOk, rsVars
    2. setRSVars: cx, rsVars, rsCode
      1. 'n' no vars
      2. 'd' describe output - no vars
      3. '' default from describe output mit ? Logik
      4. ?col → :col :col.sqlInd and logic für sqlNull
      5. unchanged to db2
    3. fetch: cx, dst, retOk
    4. close
  • update: src, retOk: ohne Resultset, execute oder executeImmediate
  • execute: cx, src, retOk, rsVars: 0-n resultsets
    1. getMoreResults
  • queryPrepare cx, src, retOk, rsVars
    1. queryWithArgs cx, args...
    2. fetch (close gehört zu prepare nicht args
  • updatePrepare cx, src, retOk
    1. updateWithArgs cx, args ...
  • executePrepare: : cx, src, retOk, rsVars
  • table mit Commas
    • die Möglichkeit die class oder eine constructor Routine mitzugeben ist nicht implementiert, erst falls das wirklich nötig wird: table (var | '.' expr)? nl? .....

Implementation Problems

  • pipe: syntax für input String, und Mischung String files (wsh und pipe!)
  • $@ exprBlock hat nachteile: $@abc funktioniert nicht mehr direkt, $@.$.abc o.ä. (siehe tst) ist kontraintuitiv - besser primary?
  • directives: alte Syntax mit benannten units wirklich überflüssig - mit $@proc erreich man selbes ... --- syntax geändert sodass zwischen $#@ und nl verarbeitet wird

idee: var = name | '{' exprS '}' und { } brauchen wir nur noch für das, block wird nur [] oder //

  • assignment geht ohne vorgängiges = (aber $= braucht es wegen primary ⇔ statment
  • überall wo var steht, hört es auch wieder auf!
  • alle $-{3*2} müssen auf $-[3*2$] geändert werden
  • alte call Syntax $@abc(), $@abc-{...} etc.. muss auf $@£[abc$] geändert werden
  • weitere tst
    • empty : and ! block
    • ! and ? für code @
  • o2JRW statt immer o2file brauchen, allgemeine a2 routinen, die aus normale Strings verstehen
  • migrate expression to AST and document in WshSem
  • clean up kinds @⇔; ==> in rexx and WshSem
  • : und ! haben 3 Semantiken: single Assignment, multi Assignmen (akutell nur auf Stems) und freies Auftreten (gibt Sequenc von neuen Objekten). an alternative syntax/semantics
    1. update current with
    2. output 0-n Objekte (mit Singleton Operator), und benutze typeInfo in stdOut um richtiges Objekt zu erstellen
    3. dann funktioniert es fast wie alle anderen Blöcke
    4. mache dafür Operator und erlaube in Directive Operatoren!
    • in the AST put a special type: WA = withAssignment: (class, assStmts) (wheter class is explicit or in the code of assStmts is an implementation variant,
    • allow stdOut to contain typing infos
    • WA uses WABegin, WANext adn WAEnd that in combination with the typeInfo in stdOut will keep the current with, push an * old obj to with or push a new obj to with. The new is from class in stdOut typeInfo if unspecified form class parms in WABegin/Next.
    • This eliminiates the complexitiy of muClass in with, and it works also with a pushWith before the WA
    • file assignment analog stem assignment (für : ! envPushName) implementieren, File mit ElementType deklarieren
  • ~ in fileSpec statt als User, als Path Expansion benutzen. Name könnte member in Lib sein, oder weitere Qualifiers. Problem: da müsste man wissen ob Input (erstes existierendes Element) oder Output (erstes Element erstellen falls nicht vorhanden)
  • auch subTypes mit oMutate markieren, Logik mit weitergegebenen Klassen brauchte es dann nur noch für Fields
  • Objekte ohne Klasse allgemein als String behandeln (wie in envCatLines) oder ist es besser das wie bis jetzt zu kontrollieren. Allenfalls ein/ausSchaltbar?
  • Version behandeln: source kann version deklarieren mit $#version= ==> neuere Version von wsh könnte alte Version simulieren oder¨Fehlermeldung machen
  • Optionen um inline Data usw zu Filtern (strip, Zeilen concat usw. z.B. wie in testInput
  • Block mit lokalen geschachtelten Variabeln - mit with harmonisiert. bessere with Semantics: mit lexial links statt hist Links!
  • $@arg statement, das ein parse, in objekt macht und with ==> Prozedur Parameter besser unterstützen
  • mapVia eliminieren bzw. besser mit oAccPath usw. integrieren
  • enviromnment file, z.B. für db2Subsys (wenn kein connect gemacht), mit dbx e kann environment modifiziert, oder ein anderes ausgewählt. Bzw. bei bestimmten RunTime Selektionen wird Env automatisch angepasst (und dann ist es für alle folgenden Calls der Default)

abgelehnte oder implementierte Ideen

  • run von JRW wegnehmen --> nein, braeuchte wieder Fallunterscheidung in run
  • in obj wird nur noch fileOperator unterstützt:
    • $.<-={a.b.c} block ist nötig um String zu scannen, - um String zurückzugeben und nicht Block als Input zu interpretieren
    • $@<a.b.c krieg dasselbe file
  • Implementierung mit AST und abstrakte Syntax ⇔ semantics dokumentieren, für Block implementiert
  • operator < kopiert file in Buffer kopieren, nur @ führt code wieder aus! funkioniert jetzt so ==> WshSem

Features

  • Routinen mit writeall (wie sqlSel) braucht es eigentlich nicht:
    • $@.selRdr(....) macht dasSelbe, und
    • $@!.selRdr(....) oder $@?selRdr(...) macht dasselbe wie sqlPreAllCl, sqlSel1 usw., die braucht es also auch nicht
  • input aus pipe oder String
    • mit envCatLines(rdr, opt) aus einem Argument holen:
      • falls rdr == '' aus standardInput zusammenkonkatinieren
      • falls rdr kein Objekt ist, als String formatieren mit jCat1(rdr, opt)
      • falls rdr descendent from JRW zusammenkonkatinieren mit jCatLines(rdr, opt)
      • sonst cast to string jCat1(o2String(rdr), opt)
  • reader → writeAll
    • rexx: call pipeWriteAll rdr()
    • wsh: $@<.rdr()
  • reader ← writeAll
    • das braucht's nur in Rexx, geht nicht einfach, ($>?, writeAll und beim pipeEnd outPutFile zurückgeben statt schreiben)
    • also writeAll Prozedur schreiben falls häufig gebraucht, sonst nur rdr
  • compiler include: $@ct $@[$a=. $.compile@ $<inputFile$]
  • lazy initialisation: $>$var initialisiert die Variable var mit einem leeren JBuf falls undefiniert oder Null
  • bringt ein Variable Access String oder Object:
    • per Default durch Kind bestimmt
      • in = - String
      • in . : ! @ Object
    • explizit (überschreibt Default von Kind)
      • $.$var Object
      • $-$var String

Syntax ⇒ Semantics

wsh ⇒ ORun
Data ⇒ ORun:

Variables, Format

  • heute in skel: $-[f('%i3', $abc)$] ==> 12 UmrahmungsZeichen!
  • f benutzt parameter, nicht variable Pool und @...%... $ syntax, nicht ${...}
    • multi format
    • 1 arg, multi arg (gebraucht?), Obj Felder, varPool
  • output auf von Objekten, zurzeit nur Objekt Identifier statt (abgekürzte?) Attribut Liste
    • o23.345=[class abc=1 e=[class efg=2 ...] g=3] (quoted falls space (und =?))
  • $table ==> objektListe nach $table format?, defaultFormate?
  • Konstanten oder keine Variabeln umformatieren?
  • ins vGet oder in compVar integrieren?

Ideen:

  • ${abc%3i}
    • wenn % hier für format steht, können wir es nicht mehr für patternMatching brauchen
    • auch 3i erlauben???
    • anstelle von parameter Syntax oder nur noch eine Variante?

ksh

http://www2.research.att.com/sw/download/man/man1/ksh.html parameter expansion

  • ${parameter }
    • The shell reads all the characters from ${ to the matching } as part of the same word even if it contains braces or metacharacters. The value, if any, of the parameter is substituted. The braces are required when parameter is followed by a letter, digit, or underscore that is not to be interpreted as part of its name, when the variable name contains a .. The braces are also required when a variable is subscripted unless it is part of an Arithmetic Expression or a Conditional Expression. If parameter is one or more digits then it is a positional parameter. A positional parameter of more than one digit must be enclosed in braces. If parameter is * or @, then all the positional parameters, starting with $1, are substituted (separated by a field separator character). If an array vname with last subscript * @, or for index arrays of the form sub1 .. sub2. is used, then the value for each of the elements between sub1 and sub2 inclusive (or all elements for * and @) is substituted, separated by the first character of the value of IFS.
  • ${#parameter }
    • If parameter is * or @, the number of positional parameters is substituted. Otherwise, the length of the value of the parameter is substituted.
  • ${#vname[*]}
  • ${#vname[@]}
    • The number of elements in the array vname is substituted.
  • ${@vname }
    • Expands to the type name (See Type Variables below) or attributes of the variable referred to by vname.
  • ${!vname }
    • Expands to the name of the variable referred to by vname. This will be vname except when vname is a name reference.
  • ${!vname [subscript ]}
    • Expands to name of the subscript unless subscript is *, @. or of the form sub1 .. sub2. When subscript is *, the list of array subscripts for vname is generated. For a variable that is not an array, the value is 0 if the variable is set. Otherwise it is null. When subscript is @, same as above, except that when used in double quotes, each array subscript yields a separate argument. When subscript is of the form sub1 .. sub2 it expands to the list of subscripts between sub1 and sub2 inclusive using the same quoting rules as @.
  • ${!prefix *}
    • Expands to the names of the variables whose names begin with prefix.
  • ${parameter :-word }
    • If parameter is set and is non-null then substitute its value; otherwise substitute word.
  • ${parameter :=word }
    • If parameter is not set or is null then set it to word; the value of the parameter is then substituted. Positional parameters may not be assigned to in this way.
  • ${parameter :?word }
    • If parameter is set and is non-null then substitute its value; otherwise, print word and exit from the shell (if not interactive). If word is omitted then a standard message is printed.
  • ${parameter :+word }
    • If parameter is set and is non-null then substitute word; otherwise substitute nothing.
  • In the above,
    • word is not evaluated unless it is to be used as the substituted string, so that, in the following example, pwd is executed only if d is not set or is null:
      • print ${d:- $( pwd ) }
    • If the colon ( : ) is omitted from the above expressions, then the shell only checks whether parameter is set or not.
  • ${parameter :offset :length }
  • ${parameter :offset }
    • Expands to the portion of the value of parameter starting at the character (counting from 0 ) determined by expanding offset as an arithmetic expression and consisting of the number of characters determined by the arithmetic expression defined by length. In the second form, the remainder of the value is used. If A negative offset counts backwards from the end of parameter. Note that one or more blanks is required in front of a minus sign to prevent the shell from interpreting the operator as :-. If parameter is * or @, or is an array name indexed by * or @, then offset and length refer to the array index and number of elements respectively. A negative offset is taken relative to one greater than the highest subscript for indexed arrays. The order for associate arrays is unspecified.
  • ${parameter #pattern }
  • ${parameter ##pattern }
    • If the shell pattern matches the beginning of the value of parameter, then the value of this expansion is the value of the parameter with the matched portion deleted; otherwise the value of this parameter is substituted. In the first form the smallest matching pattern is deleted and in the second form the largest matching pattern is deleted. When parameter is @, *, or an array variable with subscript @ or *, the substring operation is applied to each element in turn.
  • ${parameter %pattern }
  • ${parameter pattern }
    • If the shell pattern matches the end of the value of parameter, then the value of this expansion is the value of the parameter with the matched part deleted; otherwise substitute the value of parameter. In the first form the smallest matching pattern is deleted and in the second form the largest matching pattern is deleted. When parameter is @, *, or an array variable with subscript @ or *, the substring operation is applied to each element in turn.
  • ${parameter /pattern /string }
  • ${parameter //pattern /string }
  • ${parameter /#pattern /string }
  • ${parameter /%pattern /string }
    • Expands parameter and replaces the longest match of pattern with the given string. Each occurrence of \n in string is replaced by the portion of parameter that matches the n -th sub-pattern. In the first form, only the first occurrence of pattern is replaced. In the second form, each match for pattern is replaced by the given string. The third form restricts the pattern match to the beginning of the string while the fourth form restricts the pattern match to the end of the string. When string is null, the pattern will be deleted and the / in front of string may be omitted. When parameter is @, *, or an array variable with subscript @ or *, the substitution operation is applied to each element in turn. In this case, the string portion of word will be re-evaluated for each element.