EP1295219A2 - Xml flattener - Google Patents
Xml flattenerInfo
- Publication number
- EP1295219A2 EP1295219A2 EP01924935A EP01924935A EP1295219A2 EP 1295219 A2 EP1295219 A2 EP 1295219A2 EP 01924935 A EP01924935 A EP 01924935A EP 01924935 A EP01924935 A EP 01924935A EP 1295219 A2 EP1295219 A2 EP 1295219A2
- Authority
- EP
- European Patent Office
- Prior art keywords
- xml
- file
- attributes
- source
- elements
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Withdrawn
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/25—Integrating or interfacing systems involving database management systems
- G06F16/258—Data format conversion from or to a database
Definitions
- the present invention relates to a method for flattening an XML file.
- the Internet is a general purpose, public, global computer network which allows computers hooked into the Internet to communicate and exchange digital data with other computers also on the Internet. Once a computer is coupled to the Internet, a wide variety of options become available. Some of the myriad functions possible over the Internet include sending and receiving electronic mail (e-mail) messages, logging into and participating in live discussions, playing games in real-time, viewing pictures, watching streaming video, listening to music, going shopping on-line, downloading and/or uploading files, and browsing different web sites, etc.
- e-mail electronic mail
- HTTP Hypertext Transfer Protocol
- This protocol specifies a set of technical rules by which client and server programs can communicate with one another.
- HTTP is used to transfer data between servers and clients via a browser program (e.g., Navigator or Explorer) over a part of the Internet known as the World Wide Web or "the Web.”
- HTTP enables a user to simply place a cursor on a displayed hypertext link and click on it. This automatically takes the user to the appropriate web page, to other desired information, or to another resource located on the same or different server on the Internet.
- XML Extensible Markup Language
- W3C World- Wide Web consortium
- XML is a markup language for documents containing structured information. Structured information contains both content (words, pictures, etc.) and some indication of what role that content plays (for example, content in a section heading has a different meaning from content in a footnote, which means something different than content in a figure caption or content in a database table, etc.).
- XML provides a data standard that can encode the content and semantics of a document.
- a markup language is a mechanism to identify structures in a document.
- the XML specification defines a standard way to add markup to documents.
- the word "document” refers not only to traditional documents, but also to the miriad of other XML "data formats”. These include vector graphics, e-commerce transactions, mathematical equations, object meta-data, server APIs, and a thousand other kinds of structured information.
- XML requires a hierarchical programming format. To understand the components of an XML document, it is useful to look at a example. The following is a sample XML file— store.xml:
- the above XML sample represents products sold in a store.
- the first line of the XML file indicates the XML specification version:
- the XML document consists of a hierarchy of elements. Each element begins with a start tag and ends with an end tag.
- the root element is the topmost element. In the above example, the root element is STORE.
- the start and end tags for the STORE element is ⁇ STORE> and ⁇ /STORE> respectively.
- the PRODUCT element is a sub element that appears under the STORE element. In the above example, there are three products in the K&J Hardware store.
- An element can have attributes. In the above example, the PRODUCT element has the following attributes: NAME, PARTNUM, PLANT, and INVENTORY.
- the hierarchical structure of the store.xml document given above can be represented in a "tree" format as shown in Figure 1.
- the top hierarchy consists of a store (KJ-Hardware).
- the store in the next hierarchical level, has three products (Speed Drill Pro, Speed Drill, and Sawzlt).
- the next hierarchical level consists of the Specifications, Options, and Price for each of the products.
- the present invention pertains to a method and apparatus for flattening an XML file.
- XML files are stored in a client or server.
- the user specifies one of the XML files or a particular subset of the selected XML file to flatten.
- the user also specifies which elements and/or attributes of the selected subset of the XML file is of interest.
- the elements and attributes of interest to the user for the selected subset are then parsed by a parser process.
- the parsed elements and attributes are then automatically arranged into a flat format having rows and columns as defined by the user.
- Figure 1 shows a hierarchical structure of the store.xml document.
- Figure 2 shows an XML Source Metatdata Analysis process.
- Figure 3 shows an XML Source Flattening process.
- Figure 4 shows three processes: XML Parser, XML Flattener, and XML Views.
- Figure 5 shows an exemplary computer system upon which the present invention may be practiced.
- an XML Source Metatdata Analysis process is shown. Initially, an XML source 201 is accessed by an XML View process 202.
- the XML View process 202 operates on a user specified subset of an XML document retrieved from the XML source 201. This subset corresponds to a set of logically related elements and attributes.
- the XML View process 202 specifies how and what to flatten in an XML source file.
- the XML View process 202 is defined by the user in a control file. It should be noted that an XML source 201 can have multiple XML View processes 202.
- the data is then transformed according to the Metadata XML 203.
- the result is then stored in a flat file source 204.
- the XML source 301 is operated upon by the XML View process 302 (e.g., a control file) and Metadata XML 303.
- the converted flat file 304 can then be processed by a Reader process 305.
- An example of an XML Views for a particular Store is shown below.
- PROCESSTYPE "IGNORE"/>
- control file for the examples given above is given as follows. It should be noted that the control file exists in an XML format, contains the XML view definitions, and defaults to xmlfctrl.xml.
- an XMLFLAT invocation might look like: XMLFLAT [options] xml_source_file [flat_dest_file]. The following are the options that can be specified:
- control file > Control file/view for processing XML source file -v ⁇ view_name> View name in control file -a Append rows to flattened file
- Some examples of invocations include: XML Source Analysis:
- XML parsers available from different vendors. There are validating and non validating parsers. The validating parsers also verify the DTD conformance of the XML file. The following are some of the XML parsers available: IBM's XML4j; IBM's XML4c; Microsoft's MSXML; Oracle's V2 parser; Sun's 'Java Project X"; and DataChannel XML Parser for Java.
- XML or SGML
- a tree-based API compiles an XML document into an internal tree structure, then allows an application to navigate that tree.
- the Document Object Model (DOM) working group at the World-Wide Web consortium is developing a standard tree-based API for XML and HTML documents.
- An event-based API reports parsing events (such as the start and end of elements) directly to the application through callbacks, and does not usually build an internal tree.
- the application implements handlers to deal with the different events, much like handling events in a graphical user interface.
- Tree-based APIs are useful for a wide range of applications, hut they often put a great strain on system resources, especially if the document is large (under very controlled circumstances, it is possible to construct the tree in a lazy fashion to avoid some of this problem).
- some applications need to build their own, different data trees, and it is very inefficient to build a tree of parse nodes, only to map it onto a new tree.
- an event-based API provides a simpler, lower-level access to an XML document one can parse documents much larger than the available system memory, and one can construct their own data structures using their callback event handlers.
- the XML Flattener is an application which takes an XML file as input and produces a flat file that contains the XML element values and attributes in rows. Once the flat file is produced it can be used as a data source and the data can be read in by the reader. The invocation of the XML flattener can occur as a pre- session command by the server.
- the XML Flattener uses a imbedded XML parser to parse the XML file. As the elements in the XML hierarchy are parsed, they are collected in buffers and then written to a file with a user specified delimiter. Once the entire XML file is processed then the out flat file will be closed, and will be ready to be read by the XML reader.
- the flat file will have header information followed by data rows. The header will contain the column names. The column names can be generated by concatenating element names in the hierarchy chain. The following is an sample flattened representation of the sample store.xml file.
- the first row(spread through 3 rows in the document) contains the column names. There are three data rows that has the element and attribute values for the three products in the store.
- the semicolon is used as the delimiter in the above flat file.
- the delimiter itself should be user specified parameter to the XML flattener.
- Filters are used in case the user is only interested in a subset of the elements/attributes. The user should be able to specify the elements/attributes that are to be parsed or those to be ignored. The following is a flat file that has been filtered to exclude the SPECIFICATION element: STORE_N AME; STORE STATE; PRODUCT .N AME; PRODUCT_PLANT;
- Element filtering can be used for example to filter out the routing related tags from BizTalk XML schemas.
- Filters by Value provide a way to filter information from the XML file based on values of an element or attribute. For example, the user may want be only interested in all the stores in California. Having filters will reduce the size of the flattened XML file, thereby reducing the processing time for the reader to read the file.
- PRODUCT+ EMPLOYEE+ The EMPLOYEE sub element can also occur more than one under the STORE element.
- the XML flattener can process either the PRODUCT or the EMPLOYEE sub element, and not both into the same flat file. The reason is that the PRODUCT and EMPLOYEE entities do not relate to each other. They only relate to the parent STORE. On the other hand, consider the following:
- a new sub element LOCA ⁇ ON has been added which has attributes regarding the location of the store.
- the PRODUCT and LOCA ⁇ ON entities can be used in conjunction, and so can the EMPLOYEE and LOCA ⁇ ON entities.
- the XML flattener can process only one of them. In such cases the user would need to indicate which one is to be processed.
- the user can include either PRODUCT or EMPLOYEE to be processed by the XML flattener, and not both at the same time.
- the XML Flattener is an executable that can be invoked from the command line.
- the following parameters can be specified: -XML file (The source XML file) -Flat file (The flattened output file) -Delimiter -Filter parameters (For Element/ Attribute/Value based filtering) It should be possible to specify the filter parameters so that they represent elements/attributes to be ignored or processed. This will provide more flexibility for the user.
- the complexity of the input parameters may make it difficult to be processed as command line parameters. If this is the case we may have to provide a way of specifying the parameters in a control file. This control file itself could be an XML file. The details and specification of the parameters and the invocation of the XML flattener is discussed below.
- the XML flattener is a command line application that servers two purposes. It is invoked initially for any new XML source file type to capture the flattened XML source metadata and update the repository. It is also invoked as a pre-session command to flatten an XML source file so that the flattened file can be read by the Reader. XMLFlat on completion will return a status code. The value of the status code will indicate if the the XML file was processed successfully or not. The server needs to verify this status code before it starts the session to read the flattened XML file.
- the XML flattener can be invoked as follows, from the command line:
- the xrr ⁇ l_source_file is the full path of the source XML file.
- the source XML file is needed for XML source analysis and for flattening.
- the flat_dest_file is the output file for the flattened rows. The output file is required for the flattening option.
- the flat_dest_file is not needed with the -m, -p, and -ps options.
- the -v option is used to specify the view name to be used for analysis or flattening. This is a required option for all XMLFLAT invocations.
- the -c option allows you to specify a control file other than the default control file.
- the default control file is xmlfctrLxml in the same directory as the XMLFLAT executable.
- the -m option is used to analyze the source XML file and capture the source metadata.
- This metadata information defines the flat file source and column attributes and the mapping between the XML elements and attributes to flat file columns. This includes flat file source name , business name and delimiter.
- the column attributes include the column name, business name, datatype (STRING always), precision.
- the metadata is stored in XML format in the metadataj ⁇ nl file. This is used to push the flat file source metadata into the Informatica repository. This is also used during the source flattening process.
- the -p option is used to push the XML source metadata into the repository. This option assumes that the -m option was used earlier to capture the metadata into the metadata.xml file, or it is used in conjunction with the -m option. This option is discussed further in the 'XML Source Metadata Capture' section.
- the -ps option works the same as the -p option, except that the user will be prompted for the repository and database passwords. The following are example invocations of XMLFLAT for XML source analysis and metadata push
- XML Source Analysis (-m option) XMLFLAT -m -v INVENTORY store.xml XML Source Push (-p option) XMLFLAT -v INVENTORY -p testrep Administrator Administrator naresh naresh sql_srvr folderl 1.0.0 storel.xml out.txt XML Source Analysis + Push (-m,-p option)
- XMLSource Flattening Options there is no specific option to invoke flattening of XML sources. If the -m,-p, or -ps options are not used, it is assumed that the source XML file is to be flattened. The -a option is used to append rows to the output XML file. If this option is not used then the output XML file will be overwritten.
- the -b option enables one to specify a batch of source XML files for flattening. With the -b option, a batch file containing a list of source XML files is to be specified. The following is an example batch file. Note that the source XML files appear on separate lines in the batch file.
- the XML View provides a way for the user to specify a subset of a source XML file, and information regarding how to represent information in a XML document in a row structure. It also contains information about the flat file source. A single source XML file can have multiple views. An XML view contains the following information:
- XMLFALT Control File shows the DTD for the XML Flattener control file.
- the XML format is seen here as an appropriate format to represent the control file since it is platform independent and we can use a XML parser to parse the control file. It will also allow users to use any of the available XML graphical editors to specify the control parameters.
- the root element in the above DTD is XMLFLAT.
- the control file can contain the parameters for several XML source files.
- the XMLVIEW element which is a sub-element of XMLFLAT, contains the view specification for an XML source file.
- the above method allows the same source XML file in different ways. This is useful when the same XML file is to be used as a source for different information. For example, the products information from the storecard input can be flattened by specifying:
- the delimiter to be used in the flattened file is specified by the DELIMITER attribute of the XMLVIEW element.
- the SRCNAME and SRCDESC attributes of XMLVIEW are the flat file source name and description to be used when we push the metadata into the Informatica repository.
- the ELEMPROCESSTYPE attribute of XMLVIEW indicates if elements are to ignored or kept by default. This only applies to elements that do not have a corresponding ELEM sub element specification. The ELEM sub element is discussed later.
- the default value for ELEMPROCESSTYPE is 'KEEP'.
- the XMLVIEW element can have one or more sub elements of type ELEM
- the ELEM sub element provides a way to specify how an element/attribute in source XML file is to be processed.
- the PROCESSTYPE attribute of ELEM has the following possible values:
- the MULTCOL attribute of ELEM specifies that multiple occurrences of the element will be flattened to the same row in the flattened file.
- the OPTIONAL attribute of ELEM indicates if an element is optional. If the element does not exist in the source XML file then a empty string will assigned to it in the flattened file. The default value for OPTIONAL is "NO".
- the ATTRPROCESSTYPE attribute of XMLVIEW indicates if attributes are to ignored or kept by default for an element. This only applies to attributes that do not have a corresponding ATTR sub element specification. The ATTR sub element is discussed later. The default value for ATTRPROCESSTYPE is " EEP'.
- the ATTR ⁇ ub element of ELEM element provides a way to specify how a specific attribute of an element is to be processed.
- the PROCESSTYPE attribute of ATTR has the following possible values:
- the OPTION AL attribute of ATTR indicates if an attribute is optional. If the element does not exist in the source XML file then a empty string will assigned to it in the flattened file. The default value for OPTIONAL is "NO".
- control file for the store j ⁇ nl input file.
- the filter specified will only process the stores in CA.
- the ELEMFILTER sub element of ELEM provides a way to filter information from the XML source file based on element attribute values.
- the flattened file will contain rows that satisfy the filter criteria.
- the filter specification as stated allows filtering based on an attribute value of an element.
- a composite filter cannot be specified now.
- the metadata describing the flattened XML file consists of the following: the source name describing the XML source and the source field level metadata which includes the field names, data types and maximum length. Since the XML source analysis is not available in the Designer we need to provide a way for the XMLFLAT application to push the above XML source related metadata into the repository. This can be accomplished by using the -p option of the XMLFLAT:
- the user would need the invoke XMLFLAT with the -p option manually to get the XML source metatdata into the repository. From then on when XMLFLAT is invoked via a pre session command, the -p option is not needed.
- the -m option of XMLFLAT should be used to capture the source XML metadata before the -p option is used, or in conjunction with the -p option.
- the metadata is captured into an XML format in the metadata.xml file.
- the repository connection parameters that is specified with the -p option will be used by XMLFLAT to connect to the repository and push the metadata.
- the data types of the XML source fields will all be the string data type.
- the maximum length for the fields will be determined by processing the input XML source file and capturing the maximum length of data values.
- the XML file that is used during the source analysis may have data values that have shorter lengths than the XML files that are used in the sessions. If this happens then the reader will not be able to read the flattened XML file. In this case the user can invoke the Designer and specify a new maximum field length. The other options are to do the source analysis step again with an update intent. The other way, is for the user to specify maximum lengths(via the control file) to be applied for the fields.
- Errors can occur during processing of XMLFLAT. Some of the errors can be detected and XMLFLAT will return an error code. In some cases the error cannot be detected and will result in invalid information in the flattened file. Errors that can be easily detected are, for example:
- XML file is invalid(does not comply to DTD).
- XSLT XSL Transformation Language
- XSLT XSL Transformation Language
- XSLT can be used to transform XML documents into other XML documents. It could also be used to combine different XML documents into one XML document.
- XSLT can be used as preprocess step for the XML flattener when there are more than one XML source files which are to be merged before they can be flattened. There are some tools available in the market which lets you build the XSLT visually for such purposes.
- XSLT can also be used to transform complex XML documents to simpler structures that can be easily flattened. It can also be used to filter XML documents based on certain criteria before they can be processed by the XML flattener.
- FIG. 5 shows an exemplary computer system upon which the present invention may be practiced. It is appreciated that the computer system 501 of Figure 5 is exemplary only and that the present invention can operate within a number of different computer systems.
- Computer system 501 of Figure 5 includes an address/data bus 506 for conveying digital information between the various components, a central processor unit (CPU) 502 for processing the digital information and instructions, a main memory 504 comprised of random access memory (RAM) for storing the digital information and instructions, a read only memory (ROM) 503 for storing information and instructions of a more permanent nature.
- CPU central processor unit
- main memory 504 comprised of random access memory (RAM) for storing the digital information and instructions
- ROM read only memory
- computer system 501 may also include a data storage device 505 (e.g., a magnetic, optical, floppy, or tape drive) for storing vast amounts of data, and an I/O interface 510 for interfacing with peripheral devices (e.g., computer network, modem, etc.).
- data storage device 505 e.g., a magnetic, optical, floppy, or tape drive
- I/O interface 510 for interfacing with peripheral devices (e.g., computer network, modem, etc.).
- client program for performing XML flattening can be stored either in main memory 504, data storage device 505, or in an external storage device.
- Devices which may be coupled to computer system 501 include a display device 507 for displaying information to a computer user, an alphanumeric input device 508 (e.g., a keyboard), and a cursor control device 509 (e.g., mouse, trackball, light pen, etc.) for inputting data and selections.
- an alphanumeric input device 508
Landscapes
- Engineering & Computer Science (AREA)
- Databases & Information Systems (AREA)
- Theoretical Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
Description
Claims
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US547190 | 1990-07-03 | ||
US54719000A | 2000-04-11 | 2000-04-11 | |
PCT/US2001/011829 WO2001082133A2 (en) | 2000-04-11 | 2001-04-11 | Xml flattener |
Publications (1)
Publication Number | Publication Date |
---|---|
EP1295219A2 true EP1295219A2 (en) | 2003-03-26 |
Family
ID=24183686
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
EP01924935A Withdrawn EP1295219A2 (en) | 2000-04-11 | 2001-04-11 | Xml flattener |
Country Status (4)
Country | Link |
---|---|
EP (1) | EP1295219A2 (en) |
AU (1) | AU2001251542A1 (en) |
CA (1) | CA2405893A1 (en) |
WO (1) | WO2001082133A2 (en) |
Families Citing this family (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7921359B2 (en) | 2002-04-19 | 2011-04-05 | Sas Institute Inc. | Computer-implemented system and method for tagged and rectangular data processing |
US7243098B2 (en) | 2002-12-19 | 2007-07-10 | International Business Machines Corporation | Method, system, and program for optimizing aggregate processing |
US7124137B2 (en) | 2002-12-19 | 2006-10-17 | International Business Machines Corporation | Method, system, and program for optimizing processing of nested functions |
US7003722B2 (en) * | 2003-02-28 | 2006-02-21 | Microsoft Corporation | Method and system for converting a schema-based hierarchical data structure into a flat data structure |
US6990632B2 (en) | 2003-02-28 | 2006-01-24 | Microsoft Corporation | Method and system for inferring a schema from a hierarchical data structure for use in a spreadsheet |
EP1628227A4 (en) * | 2003-05-22 | 2010-07-07 | Sharp Kk | Data processing device, data processing method, data processing program, and computer-readable recording medium containing the data processing program |
US7120864B2 (en) | 2004-01-27 | 2006-10-10 | International Business Machines Corporation | Eliminating superfluous namespace declarations and undeclaring default namespaces in XML serialization processing |
EP1688850A1 (en) | 2005-02-07 | 2006-08-09 | Sony Ericsson Mobile Communications AB | Generic parser for electronic devices |
-
2001
- 2001-04-11 CA CA002405893A patent/CA2405893A1/en not_active Abandoned
- 2001-04-11 AU AU2001251542A patent/AU2001251542A1/en not_active Abandoned
- 2001-04-11 WO PCT/US2001/011829 patent/WO2001082133A2/en not_active Application Discontinuation
- 2001-04-11 EP EP01924935A patent/EP1295219A2/en not_active Withdrawn
Non-Patent Citations (1)
Title |
---|
See references of WO0182133A2 * |
Also Published As
Publication number | Publication date |
---|---|
WO2001082133A3 (en) | 2003-01-23 |
CA2405893A1 (en) | 2001-11-01 |
AU2001251542A1 (en) | 2001-11-07 |
WO2001082133A2 (en) | 2001-11-01 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
TW571204B (en) | Content publication system for supporting real-time integration and processing of multimedia content including dynamic data, and method thereof | |
US7624114B2 (en) | Automatically generating web forms from database schema | |
US6732331B1 (en) | System and process for managing content organized in a tag-delimited template using metadata | |
US7296263B1 (en) | Method and system for performing operations on data using XML streams | |
US7526490B2 (en) | Method of and system for providing positional based object to XML mapping | |
US6456308B1 (en) | Embedded web server | |
US20040268238A1 (en) | Systems and methods for processing documents using an XML-based process flow description language | |
US7210097B1 (en) | Method for loading large XML documents on demand | |
US6964015B2 (en) | Redline extensible markup language (XML) schema | |
US20020147745A1 (en) | Method and apparatus for document markup language driven server | |
US20040054969A1 (en) | System and method for generating web services definitions for MFS-based IMS applications | |
US20030088586A1 (en) | User interface for a multi-dimensional data store | |
US7613723B2 (en) | Configurable framework for storing and retrieving arbitrary information from a database | |
JP2005507523A (en) | Improvements related to document generation | |
JP2004334866A (en) | Conversion of web site summary through tag rib | |
JP2003512666A (en) | Intelligent harvesting and navigation systems and methods | |
US20100049774A1 (en) | Object Structure-Based System and Method for Managing Information | |
EP1283993A2 (en) | Method and system for building internet-based applications | |
US20070027897A1 (en) | Selectively structuring a table of contents for accesing a database | |
US7877434B2 (en) | Method, system and apparatus for presenting forms and publishing form data | |
US20050160070A1 (en) | Systems engineering document prototyping system, program product, and related methods | |
WO2001082133A2 (en) | Xml flattener | |
US7447697B2 (en) | Method of and system for providing path based object to XML mapping | |
US7296034B2 (en) | Integrated support in an XML/XQuery database for web-based applications | |
EP1228444A2 (en) | Apparatus, systems and methods for electronic data development, management, control and integration in a global communications network environment |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
PUAI | Public reference made under article 153(3) epc to a published international application that has entered the european phase |
Free format text: ORIGINAL CODE: 0009012 |
|
17P | Request for examination filed |
Effective date: 20021106 |
|
AK | Designated contracting states |
Kind code of ref document: A2 Designated state(s): AT BE CH CY DE DK ES FI FR GB GR IE IT LI LU MC NL PT SE TR Designated state(s): AT BE CH CY DE DK ES FI FR GB GR IE IT LI LU MC NL PT SE TR |
|
AX | Request for extension of the european patent |
Extension state: AL LT LV MK RO SI |
|
17Q | First examination report despatched |
Effective date: 20050119 |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN |
|
18D | Application deemed to be withdrawn |
Effective date: 20050531 |