$ude ("export")

Export development object definitions from the Repository.

$ude ("export", ObjectType, ObjectProfile, {ZipArchive:}FileName {, OptionList} )

Example: vResult = $ude("export", "variables", "*", "D:\export\UGENERAL.xml", "append=true;library=UGENERAL")

Parameters

Parameters
Parameter	Data Type	Description
ObjectType	String	List of development object types. See Object Types.
ObjectProfile	String	String specifying an object name or retrieve profile for one or more objects of type ObjectType
ZipArchive	String	Optional name of a zip archive to contain one or more XML files, for example `ziparchive.zip` (the full string would be `ziparchive.zip:myxmlfile.xml`) When a ZipArchive is specified, it is created in the Zip64 format.
FileName	String	String specifying the name of a Uniface XML file, for example `myxmlfile.xml`
OptionList	String	Associative Uniface list containing one or more options that are appropriate to the ObjectType.See Options.

Arguments can also be a field, variable, or function that evaluates to a string or list.

Object Types

When using $ude to export development objects, you must specify the ObjectType and ObjectProfile. For global objects, IncludeProcs, and snippets, the specialized library that contains the objects is exported along with the objects that match the object profile.

For example:

To export all component development objects that begin with MUSIC:
```
vResult  = $ude("export", "component", "MUSIC*", "musiccpt.xml")
```

To export all entities belonging to the SALES model:

vResult  = $ude("export", "entity", "*", "sales.xml", "model=sales")

To export Global ProcScripts from all Global ProcScript libraries:
```
vResult  = $ude("export", "proc", "*", "libprc_all.xml")
```

To export only the Global ProcScripts from the MYPROCs library:

vResult  = $ude("export", "proc", "*", "libprc_myprocs.xml", "library=myprocs")

To export only the G_ADD Global ProcScript from the OTHERPROCS library:

vResult  = $ude("export", "proc", "G_ADD", "libprc_other.xml", "library=otherprocs")

Use the following object type keywords to specify the objects to export:

Object Type keywords
Object	Description
`signature`	Component signatures.
`component`	Components, of all types.
`component;application`	Components and Application Shells.
`application`	Application Shells.
`model`	All modeled entities that share the same model name. Deprecated. Use `$ude ("export", "entity",,,"model=Name")` instead.
`model;dtd`	All modeled DTDs that share the same model name. Deprecated. Use `$ude("export", "dtd")` instead.
`dtd`	All modeled DTDs that match the specified profile.
`entity`	One or more modeled entities that match the specified profile. ObjectProfile specifies a list of entity names without the model name. OptionList specifies the model name.
`entity;interface`	Modeled entity interfaces.
`field;interface`	Modeled field interfaces.
`field;layout`	Modeled field layouts.
`field;syntax`	Modeled field syntaxes.
`include`	Library of IncludeScripts.
`snippet`	Library of code snippets.
`variables`	Library of global variables.
`proc`	Library of global ProcScripts.
`message`	Library of messages.
`device_table`	Library of device translation tables.
`translation_table`	Library of keyboard translation tables.
`menu`	Library of menus
`panel`	Library of panels
`glyph`	Library of glyphs
`format`	Library of drag-and-drop formats
`project`	Project, including all its references to projects, modeled entities, application shells, (modeled) components, component templates, IncludeScript libraries, and code snippet libraries. The referenced objects are not included. To include referenced objects, use `FullProject` in the OptionList.

Options

The OptionList enables you to influence how the operation works based on the object. For example, you can provide additional details about the objects you want to export, such as the library and language of global objects.

The OptionList is an associative list containing at least one option and value. Use Gold ; in specifying multiple options.

Options
Option	Description
`append=True` \| `False`	Appends the objects or data to an existing XML file. The XML file may be located within a zip archive.
`keepopen=True` \| `False`	If `True`, keeps an XML file open in preparation for appending more data. By default, `export` flushes and closes the file each time. However, to improve performance in cases when appending to a file, use this option to keep the file open. If you set this option to `True`, you must explicitly flush and close the file using flush or lflush.
`printinterval=`Number	Frequency with which a message is displayed, expressed as a number of occurrences
`commitinterval=`Number	Frequency with which data is stored in the database, expressed as the number of occurrences
`CompIsLeading=True` \| `False`	If `True`, the export sequence is based on components, not subsystems, if ObjectType is `signature`
`inclCompDef=True` \| `False`	If `True` and ObjectType is `signature`, includes component definitions when exporting.
`subsystem` `=` SubsystemName	Restricts the signatures to be exported to the specified subsystem, if ObjectType is `signature`. Profile characters can be used, for example, `!XYZ` exports all except signatures in the XYZ subsystem.
`usedefsubsys` `=` `True` \| `False`	If `True`, signatures are exported from the default subsystem. If `False`, signatures are exported from the subsystems specified by option `subsystem`. Note: Use either `usedefsubsys=True` or `subsystem=`SubsystemName, but not both.
`library=`LibraryName	Specifies the name of the library to export, if ObjectType is `snippet` \| `variables` \| `proc` \| `include` \| `entity_interface` \| `field_interface` \| `field_layout` \| `field_syntax` \| `device_table` \| `translation_table` \| `panel` Different types of libraries, such as a message library and a menu library can have the same name.
`language=`Language	Specifies the language if ObjectType is `library;`{`message` \| `glyph` \| `format` \| `menu`}
`syntax=`SnippetSyntax	For snippet libraries only, specifies the syntax of snippets to be exported; one of `proc` \| `html` \| `text`.
`class=`	Specifies the class (size and GUI platform) if ObjectType is `glyph`.
`model=`	Specifies the namespace of the entities to export, if ObjectType is `entity` or `dtd`.
`FullProject=True` \| `False`	If `True`, the specified project and all the referenced objects are exported.
`RecursiveProject=True` \| `False`	If `True`, any project referenced in the specified project is exported.

Return Values

$ude returns the number of records where an attempt was made to process them. This may differ from what is expected.

Values returned by $ude and entitycopy
Value	Description
>=`0`	Success. Number of records where an attempt was made to process them. Detailed information is returned in $procReturnContext.
<`0`	An error occurred. $procerror contains the exact error and $procerrorcontext provides the details.
`8066`	8066- Copy failed: Open error on input file/table. This error can occur when no entity descriptors cannot be found.

Errors from -1 through -15 do not stop $ude processing, with the exception of error -9 <UIOSERR_LOGON_ERROR>. The number of ignored errors is returned in $procreturncontext, along with additional information, such as the Uniface release number of the source data, the number of input and output records processed, and messages, warnings, and errors encountered during processing.

Results

Items are omitted if their value is 0 or an empty string.

Items Returned by $procreturncontext
Item	Description
`Context` `=` Context	Context of the information. For $ude("export"), the value is `UDE Export`.
`InputRecords` `=` Number	Records to be exported.
`OutputRecords` `=` Number	Records actually exported.
`WriteErrorsContinues` `=` Number	Write errors encountered that did not stop the export action.
`InputDescriptors=Number`	Descriptors to be exported. The same descriptor can occur more than once.
`OutputDescriptors` `=` Number	Signatures actually exported. This can be less than the number of `InputDescriptors` if void mappings are encountered.
`DETAILS` `=` String	Messages, warnings, and errors encountered during processing, structured as a list.

Use

$ude("export") requires a fully configured Repository to be available.

Note: The $ude functions can only be used in components or applications that are run on Windows, and they rely on functionality that is provided in the ide.uar. To use $ude functions, run components and applications with ide.exe, or configure the application to include usys:ide.uar in its resources.

Allowed in all component types except self-contained Services.

Description

Use $ude("export") to export the definitions of main development objects, including their subobjects.

The $ude("export") function enables you to create components that support your own development processes, for example, in automating exports and backups. (To export application data, use $ude("copy") or entitycopy.)

Uniface exports data as well-formed, well-defined XML in which objects that have aggregation relationships are nested. The export facility takes referential integrity constraints into account, ensuring that all the data applicable to an object definition is correctly exported.

Sort Order

Definitions are exported in order of primary key. However, the database collation setting of the DBMS also affects the sort order. For example, special characters such as the underscore _) may be sorted before numbers, or before letters, which can result in records being sorted as CPT1, CPT_1, CPT, and so on, or as CPT, CPT_1, CPT1.

This can be a problem when merging exports in a development team in which each developer uses a different DBMS for the Repository, or when switching to a new DBMS. To ensure that the sort order of export files is exactly the same regardless of the database used, ensure that the database collation setting of each database is the same (or compatible).

Exporting Definitions

The following instruction exports all components whose names start with my to the mycomponents.xml XML file in the myzip.zip archive:

vResult  = $ude("export", "component", "my*", "xml:myzip.zip:mycomponents.xml")

The following instruction exports all IncludeScript in the mylib library to the includes.xml file in the myzip.zip archive:

vResult  = $ude("export", "include", "*", "xml:myzip.zip:includes.xml", "library=mylib")

The following instruction exports entity CUSTOMER and all entities whose names start with ORDER , with model name ACME, to the acme_customer.xml XML file in the myzip.zip archive:

vResult  = $ude("export", "entity", "customer;ORDER*", "xml:myzip.zip:acme_customer.xml", "model=acme")

Exporting Library Definitions

Libraries are typed, meaning each library can only contain one type of object. However, libraries of different types can have the same name.

To export all object definition in the MUSIC library, you need to specify each type of object:

; *** export an entire library ***
vExport = $ude("export", "variables", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "proc", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "include", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "snippet","*", "musiclib.xml","append=true;library=MUSIC")
vExport = $ude("export", "device_table", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "translation_table", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "panel", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "message", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "glyph", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "format", "*", "musiclib.xml", "append=true;library=MUSIC")
vExport = $ude("export", "menu", "*", "musiclib.xml", "append=true;library=MUSIC")

Exporting Global Constants

By specifying an object profile you can export a subset of library objects, or even a specific development object.

For example, in Uniface 10 global constants can be defined in the DEFPARAM IncludeScript of a library. To export global constants, you must therefore specify the specific IncludeScript:

vExport = $ude("export", "include", "DEFPARM", "globalConstants.xml", "append=true;library=MUSIC")

They are automatically exported when exporting all objects in an IncludeScript library.

Exporting a Snippet Library

The following command exports all snippets in a snippet library called MY_SNIPLIB to a file called snippet.xml:

vResult  = $ude("export","snippet","","snippet.xml","library=my_sniplib")

Snippets can have a syntax (ProcScript, HTML, or text), which is reflected in the snippet extension. Thus, it is possible to have a snippets named mysnippet.proc, mysnippet.html, and mysnippet.text.

To export only the HTML snippets, specify the syntax option:

vResult = $ude("export","snippet","","snippet.xml","library=mysniplib;syntax=html

Example: Exporting a Full Project including Referenced Objects

When exporting a project, referenced objects are only included if you use the FullProject OptionList parameter.

In this example, there are two projects, Project1 and Project2. Project1 contains two components (DSP1 and SVC1) as well as Project2. Project2 also contains two components: DSP2 and SVC2.

To export just Project1, without the objects it references, use:
```
vResult  = $ude("export", "project", "project1", "export.xml")
```
To export any referenced entities, components, and libraries, specify the option FullProject.
```
vResult  = $ude("export", "project", "project1", "export.xml", "FullProject=True")
```
This exports:
- Project1
- References to DSP1, SVC1, and Project2
- Objects DSP1 and SVC1
To also export Project2, specify the option RecursiveProject.
```
vResult  = $ude("export", "project", "project1", "export.xml", "RecursiveProject=True")
```
This exports:
- Project1
- References to DSP1, SVC1, and Project2
- Project2
- References to DSP2 and SVC2. Project2's objects are not exported.
To export everything, specify both FullProject and RecursiveProject.
```
putitem/id vOptions, "FullProject", "true"
putitem/id vOptions, "RecursiveProject", "true"
vResult  = $ude("export", "project", "project1", "export.xml", vOptions)
```
This exports:
- Project1
- References to DSP1, SVC1, and Project2
- Objects DSP1 and SVC1
- Project2
- References to its objects CPT2 and SVC2
- Objects DSP2 and SVC2

History
Version	Change
10.3.03.006	Added options `FullProject` and `RecursiveProject`
10.3.01	Removed `library` as an ObjectType. It is accepted but does nothing.
9.1.01	Introduced