Link: start
   Link: parent
   Link: First page in set (first)
   Link: Previous page (previous)
   Link: Next page (next)
   Link: Last page in set (last)
   Link: A plain text version of this page (alternate)
   Link: The XIST source of this page (alternate)
   Link: The Python module described in this page (alternate)

                             XIST.ns.toxic
                             =============

Generate Oracle functions from PL/SQL embedded in XML
=====================================================

   Home > Python software > ll.xist > ns > toxic Text · XIST · Python

   Python softwarelist of projects

     * ll.xistAn extensible XML/HTML generator

          * ExamplesParsing/creating/modifying XML; Traversing XML
            trees
          * HowtoExplains parsing/generating XML files, XML
            transformations via XIST classes and other basic
            concepts.
          * SearchingHow to iterate through XIST trees
          * TransformationHow to transform XIST trees
          * Advanced topicsPool chaining, converter contexts,
            validation
          * MiscellaneousExplains various odds and ends of XIST
          * xscXIST core classes
          * nsPackage containing namespace modules

               * htmlHTML namespace
               * xmlNamespace implementing global XML attributes
               * wmlWML 1.3 namespace
               * ihtmlNamespace implementing i-mode compatible HTML
               * docbookNamespace implementing DocBook 4.3
               * svgNamespace implementing SVG 1.0
               * abbrNamespace containing abbreviation entities
               * codeNamespace for embedding Python code in XML
               * formNamespace implementing form related elements
               * phpNamespace for PHP processing instructions
               * jspNamespace for JSP code as processing instructions
               * metaNamespace containing meta information elements
               * rubyNamespace implementing the W3C ruby draft
               * specialsCommon useful elements
               * htmlspecialsCommon useful elements for HTML
                 generation
               * docNamespace for automated documentation generation
               * kidNamespace for Kid templates
               * detoxNamespace for detox templates
               * toxicEmbed PL/SQL in XIST XML

               * rngNamespace for Relax NG
               * rss091Namespace for RSS 0.91
               * rss20Namespace for RSS 2.0
               * atomNamespace for Atom 1.0
               * struts_htmlNamespace for Jakarta Struts HTML tags
               * struts_configNamespace for Jakarta Struts
                 configuration file tags

          * parseParsing XML
          * presentScreen output of XML trees
          * simsSimple schema validation
          * xfindTree iteration and filtering
          * cssCSS related functions
          * scriptsScripts for text conversion and creating XIST
            namespaces
          * HistoryChangeLog for XIST
          * InstallationHow to install and configure XIST
          * MigrationHow to update your code to new versions of XIST
          * Mailing listsHow to subscribe to the XIST mailing lists

     * ll.ul4cA templating language
     * ll.urlRFC 2396 compliant URLs
     * ll.makeObject oriented make replacement
     * ll.daemonForking daemon processes
     * ll.sisyphusWriting cron jobs with Python
     * ll.colorRGB color values and color model conversion
     * ll.miscMisc utility functions and classes
     * ll.orasqlUtilities for cx_Oracle
     * ll.nightshadeServe the output of Oracle functions/procedures
       with CherryPy
     * ll.scriptsScripts for UL4 template rendering and URL handling
     * AploraLogging Apache HTTP requests to an Oracle database
     * PycocoPython code coverage
     * DownloadLinks to Windows and Linux, source and binary
       distributions
     * Source codeAccess to the Mercurial repositories

   This module is an XIST namespace. It provides the processing
   instruction classes needed to create TOXIC functions and
   procedures via XIST. For more info about the TOXIC compiler see
   the module ll.toxicc.

                   class args(ll.xist.xsc.ProcInst):
                   ==================================

   Specifies the arguments to be used by the generated function. For
   example:

 <?args
         key in integer,
         lang in varchar2
 ?>

   for Oracle, or:

 <?args
         @key int,
         @lang varchar(10)
 ?>

   for SQL Server. If args is used multiple times, the contents will
   be concatenated with a , inbetween.

                   class vars(ll.xist.xsc.ProcInst):
                   ==================================

   Specifies the local variables to be used by the function. For
   example:

 <?vars
         buffer varchar2(200) := 'foo';
         counter integer;
 ?>

   for Oracle, or:

 <?vars
         declare @buffer varchar(200) := 'foo';
         declare @counter int;
 ?>

   If vars is used multiple times, the contents will simple be
   concatenated. (Note that for SQL Server this could be done via a
   normal code PI too.)

                   class code(ll.xist.xsc.ProcInst):
                   ==================================

   A SQL code fragment that will be embedded literally in the
   generated function. For example:

 <?code select user into v_user from dual;?>

   for Oracle, or:

 <?code set @user = user;?>

   for SQL Server

                   class expr(ll.xist.xsc.ProcInst):
                   ==================================

   The data of an expr processing instruction must contain a SQL
   expression whose value will be embedded in the string returned by
   the generated function. This value will not be escaped in any way,
   so you can generate XML tags with expr PIs but you must make sure
   to generate the value in the encoding that the caller of the
   generated function expects.

                   class proc(ll.xist.xsc.ProcInst):
                   ==================================

   When this processing instruction is found in the source compile
   will not generate a function as a result, but a procedure. This
   procedure must have c_out as an "out" variable (of the appropriate
   type (see type) where the output will be written to.

                   class type(ll.xist.xsc.ProcInst):
                   ==================================

   Can be used to specify the return type of the generated
   function/procedure. The default is clob for Oracle and
   varchar(max) for SQL Server.