Database.Guide

Table of contents

Maps a class or an enum type to an XML element.

See «Package Specification» in javax.xml.bind.package javadoc for
additional common information.

Example 1: Associate an element with XML Schema type

//Example: Code fragment corresponding to XML output
marshal( new Point(3,5), System.out);

The annotation causes an global element declaration to be produced
in the schema. The global element declaration is associated with
the XML schema type to which the class is mapped.

Example 2: Orthogonality to type inheritance

Example 3: Associate a global element with XML Schema type
to which the class is mapped.

XML Introduction

What is Markup?

XML as a markup language characterizes a set of rules for encoding scripts (documents) in an arrangement that is both comprehensible and machine-decipherable. Thus, a developer would love to ask know, what precisely is a markup language? Markup is data added to a script that upgrades its significance in so many ways, it distinguishes, however, the components and how they identify with one another. Particularly, a markup language is a bunch of emblems that can be put in the content of a script to differentiate and name the pieces of that script.

The process of the invention of XML started around the 1990s with the sole aim of integrating the definition of new text elements. XML Working Group (Initially known as the SGML Editorial Review Board) created XML in the year 1996. The group was led by Jon Bosak of Sun Microsystems with the dynamic cooperation of an XML Special Interest Group (recently known as the SGML Working Group) likewise sorted out by the W3C. Don Connolly who filled in as the Working Group’s contact was among the team as a contact with the World Wide Web Consortium (W3W).

The plan objectives for XML are:

XML syntax rules are strongly and very simple logically. XML syntax rules are specifies how to write valid XML document.

8 XML Syntax Rules for Write Valid or Well Formatted XML Document

XML document must have only one root element that is the parent of the all other elements.

Element must have closing tag

In HTML, some element does not have a closing tag.

In XML every element must have closing tag.

Element must be properly nested

In XML, every element properly nested within each other.

XML Comments

Write comment in XML is similar to a HTML,

XML tag case sensitive

XML elements can have specifies several attributes along with name value pair. XML attribute values must be quoted.

White-space is not preserved in XML

XML break multiple white space character to a single white-space.

Output value combine multiple white space into single white space.

Entity Support

In XML special character have some special meaning similar to a HTML.

If you’re using FOR XML in SQL Server to output your query results as XML, you might find yourself in the situation where the XML returned has no root element. Fortunately adding a root element is easy, as I’ll show you in this article.

The ROOT Argument

To add a root element when using FOR XML, all we need to do is append ROOT (‘RootName’) to our query, being sure to use a comma to separate this argument with the rest of the query. Simply replace RootName with the name you want to give to the root element.

Example

Here’s an example of adding a root element when running a query with FOR XML AUTO:

SELECT
Owners.FirstName AS «OwnerFirstName»,
Owners.LastName AS «OwnerLastName»,
Pets.PetId,
Pets.PetName,
Pets.DOB,
PetTypes.PetType
FROM Pets
INNER JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId
INNER JOIN Owners ON Pets.OwnerId = Owners.OwnerId
ORDER BY Owners.OwnerId
FOR XML AUTO, ROOT (‘PetHouse’);

Here I added a root called PetHouse. We can simply change the name of the root element by changing PetHouse to something else.

Default Root Name

We can also add a root element without specifying its name. To do this, we can just specify ROOT without anything else:

SELECT
Owners.FirstName AS «OwnerFirstName»,
Owners.LastName AS «OwnerLastName»,
Pets.PetId,
Pets.PetName,
Pets.DOB,
PetTypes.PetType
FROM Pets
INNER JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId
INNER JOIN Owners ON Pets.OwnerId = Owners.OwnerId
ORDER BY Owners.OwnerId
FOR XML AUTO, ROOT;

In other words, naming the root element is optional.

Without the Root Element

Here’s an example of what happens when we don’t add a root element:

SELECT
Owners.FirstName AS «OwnerFirstName»,
Owners.LastName AS «OwnerLastName»,
Pets.PetId,
Pets.PetName,
Pets.DOB,
PetTypes.PetType
FROM Pets
INNER JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId
INNER JOIN Owners ON Pets.OwnerId = Owners.OwnerId
ORDER BY Owners.OwnerId
FOR XML AUTO;

This time there’s no root element, and the Owners elements are at the top level.

Features of XML

HTML and XML

XML Code

If you said the two root elements were «phonebook» and «diary», then you got it right! Phone book is the first element to appear in this file, so it is automatically a root element.

The syntax rules of XML are exceptionally basic and cogent. The standards are anything but straightforward to learn and simple to utilize. Under this part, we are going to simply explore the basic syntax rule for writing an uncomplicated XML document.

You can see there are two sorts of data in the above model –

Self – Describing Syntax:

XML has a very self-descriptive syntax.

A prologue specifies the XML version as well as the character encoding:

Example of XML Document:

XML DOM

The Document Object Model (DOM) is XML’s foundation. XML documents contain a hierarchy of informative units known as nodes; DOM defines those nodes and their relationships.

A DOM document is a hierarchical collection of nodes or pieces of information. This hierarchy enables a developer to search the tree for specific information. The DOM is said to be tree-based since it is based on a hierarchy of information.

The XML DOM, on the other hand, includes an API that allows a developer to add, modify, move, or remove nodes in the tree at any time throughout the development process.

Example of XML DOM

The sample.html example parses an XML document (“address.xml”) into an XML DOM object and then extracts some information from it using JavaScript.

Contents of sample.html

Now, retain these two files, sample.html and address.xml, in the same directory /XML and run the sample.html file in any browser. This should result in the output shown below.

Example for DOM

Name: KarunaCompany: CernerPhone: (91) 8364682929

XML Elements

Syntax Rules for Elements and Tags

Element syntax: Each XML element should be closed either with the start elements or end elements as appeared below

or on the other hand in basic cases, simply along these lines −

Elements nesting: XML element may contain various XML elements as its kids, however, the kids elements must not in any way over-lap – that’s an end-tag of an element must contain a similar name as that of the latest unrivaled start-tag.

An XML document can contain just one root element. For instance, an example given below isn’t correct XML-document, in light of the fact that both a and b elements happen at the high level without a root element.

Case Sensitivity: XML-elements names are case sensitive. The names of XML-components are case-touchy. That implies the name of the start-elements and end-elements should actually be in a similar case.

As rightly stated above, XML is case sensitive.  XML is a case sensitive language.

This is correct

This is incorrect

The first letter of the start-tag is in small letter, while the first letter of the end-tag is in capital letter, and hence, this is an incorrect/invalid XML.

Root Element is mandatory in XML: XML-document must contain a root-element. A root-element can contain child-elements have and sub-child elements.

The accompanying XML document is invalid, for there exists no root-element.

XML elements must contain an end-tag. Most XML documents must contain an end-tag.

It’s invalid to discard the end-tag when you’re making XML syntax. XML-elements must contain an end tag.

Element Type Declarations

Find examples of element type declarations:

Element-type mustn’t be declared more than one time.

An element-type has element content when elements of that type SHOULD have only child elements, alternatively isolated by white-space (characters matching the non-terminal S). Definition: For this situation, the limitation incorporates a content model, a Basic English structure influencing the permitted types of the child elements and the order in which they are permitted to appear.

The grammar is built-on content particles, which has names, choice-lists-of-content-particles, or sequence-lists-of-content-particles:

Proper Group/PE Nesting

XML Namespaces

In XML, the names of the tags used are defined by the developer. While mixing the XML documents from different XML applications, this naming might result in conflicts. So, XML namespaces provide a method to avoid this issue of element name conflicts.

Name Conflict Example:

Using Prefix to Solve Name Conflict

Name prefix can be used in XML to avoid name conflicts.

XML Parser

The XML parser is a package or a software library that provides an interface for the applications of clients to work with XML documents. It may validate the XML documents and checks for a proper format for the XML document. Programs use XML with the help of an XML parser.

Types of parsers:

The Document Object Model (DOM) parser loads the document’s complete contents and creates its entire hierarchical tree in the memory to parse a document. DOM parser is officially recommended by the World Wide Web Consortium (W3C).

Make use of a DOM parser when :

Simple API for XML (SAX) does not load the complete document in the memory; instead, it parses the document on event-based triggers. No parse trees are created by SAX Parser. SAX is a streaming interface for XML, i.e. that when the XML document being processed an element and attribute, applications using SAX receive event notifications at a time in chronological order, starting from the beginning of the XML document and ending with the closing of the ROOT element.

Use a SAX Parser when:

JDOM Parser is a Java developer-friendly API, Java-optimised and uses Java collections like Lists and Arrays. It works along with DOM and SAX APIs, combining the best of the two. It uses less memory and is as fast as SAX.

It parses in the same way as the SAX parser but in a more efficient manner.

It parses an XML document based on the expression. It is extensively used in conjunction with XSLT.

It is a java library that uses Java Collections Framework to parse XML, XPath and XSLT. DOM4J parser also provides support for DOM, SAX and JAXP

Text String Parsing:

Quick Learning Check:

Found Something Wrong in this Lesson?

Report a Bug or Comment on This Lesson — Your input is what keeps Tizag improving with time!

XML Documents

As characterized in this particular, a data object becomes an XML document once it is well-formed. A very much formed XML document may, moreover, be legitimate if some precise requirements are met. Physical structure and logics exist in every single XML document. Actually, the document is formed of divisions that are named substances (entities). An entity may allude to different entities to push their integration and consideration in the document. That said, a document begins in a document entity. Coherently, the document is made out of declaration, component or elements, comments, character references, and processing instruction, which are all shown by explicit markup. Properly, the physical structure and logic must nest ultimately.

For every XML document, it must have a solitary tag-pair to characterize a root element. All different elements must be inside this root element. Also, all elements can now have sub-elements. The so-called sub-elements must be appropriately nested inside their parent element.

Now, take a look at this example:

XML Document Rules

In the event that you’ve seen HTML documents, you’re acquainted with the essential ideas of utilizing tags to markup the content of a document. This segment examines the contrasts between HTML records and XML documents. It goes over the essential principles of XML documents and talks about the phrasing used to depict them.

One significant point about XML documents is: The XML detail requires a parser to dismiss any XML document that doesn’t adhere to the fundamental principles. Virtually all HTML parsers will acknowledge messy markup, thereby, making a theory with respect to what the developer of the document proposed. To dodge the approximately organized wreck found in the normal HTML document, the makers of XML chose to uphold document structure from the earliest starting point.

Note: A parser is a bit of code that endeavors to pursue a document and decipher its substance/contents.

There are three types of XML documents:

1. Valid Document: Valid documents observe both the XML syntax structure rules and the standards characterized in their DTD or composition (schema).

2. Invalid Document: Invalid documents don’t keep the syntax structure rules characterized by the XML particular. Once a developer characterizes some certain rules for what a document may contain in a DTD or schema, and the document doest observe those rules of a developer, then, that document remains invalid.

3. Well-formed documents keep the XML syntax structure rules yet don’t have a DTD or pattern (schema).

The root component

Are you excited to explore examples? Let us roll on this one

Here comes a document that doesn’t contain a single root element:

An XML parser is designed to dismiss this document, nonetheless, of the data, it might contain.

Well-Formed XML Documents

i. If taken overall, it coordinates the creation named document.

ii. If it plays catch-up with all the well-formedness requirements given in this detail.

iii. For each of the parsed elements which are referred to in a direct or indirect way in the document is well-formed

document ::= prolog element

Coordinating the document creation infers that:

i. It has at least one or more than one element.

ii. Or, there is actually one element, called the root, document element, no portion of which shows up in the substance of some other element. For every other element, if the beginning tag is in the substance of another element, the end-tag is in the substance of a similar element. All the more just expressed, the elements, delimited by the beginning-and end-tags, nest appropriately inside one another.

As an outcome of this, for each non-root component X in the document, there is one other element Y in the document with the end goal that X is in the substance of Y, however, isn’t in the substance of whatever other elements that are in the substance of Y. Y is alluded to as the parent of X, and X as an offspring of Y.

XML data consists of an essential unit called an XML document, and this particular unit is made out of elements, plus another markup in an old package. In precise, an XML document has a wide vast assortment of data. For instance, raw data of numbers, numbers in the textual representation of molecular-structure, or numerical equations.

1. Document Prolog Section: This singular part of the document reign at the top of the document, before the document element (root element). It contains the XML declaration and Declaration type of a document.

2. Document Elements Section: The document elements are the backbone of XML. It divides the document into some sort of segment, each filling a particular need. Therein, you can isolate a document into numerous segments; hence, they can be delivered in an unexpected way, or utilized through a search engine. The elements can be described as containers with a mix of texts, and different elements.

XML Document Example

DTD vs XSD

Here are some significant XML historical milestones:

• IETF Proposed Standard: XML Media Types, January 2001
• Sun Microsystems pioneered the invention of XML in 1996.

XML Element & Attribute Code

In an XML file, there can only be one root element. The root element must encapsulate all other elements—meaning, these other elements must show up after the opening root tag and before the closing root tag. Here is an example of an XML document with the root element «phonebook».

SAX XML

What is XML Parser?

A software library or package that provides interfaces for client programmes to operate with an XML document is known as an XML parser. The XML Parser is intended to read XML and provide a means for programmes to use XML.

The XML parser checks the document and ensures that it is properly formatted.

Let’s look at the diagram below to see how an XML parser works:

Features of SAX Parser:

1) It is simple and uses little memory.

2) It is highly fast and can handle large documents.

2) Because the data is fragmented, clients never have access to the entire picture.

Parts of an XML Document

White-space is essentially clear/blank space made via carriage returns, line feeds, tabs, or potentially spaces. White-space doesn’t influence the processing of the document, so you can decide to incorporate white-space or not. Actually, the XML recommendation determines that XML-documents utilize the UNIX convention for line endings. This implies that you should utilize a linefeed character just (ASCII code 10) to indicate the end of a line.

Discussing white-space, there’s an special attribute (xml:whitespace) that you can use to preserve white-space inside your elements (however we won’t fret about that a few seconds ago).

White-spaces are preserved in XML

Dissimilar to HTML that doesn’t preserve white-space, the XML-document preserves white-spaces.

White Space Handling

An XML-processor must consistently pass all characters in a document that aren’t mark-up through to the application. A validating XML-processor must likewise inform the application which of these characters constitutes white-space appearing in element content. An exceptional attribute named xml:space maybe joined to an element to single an expectation that in that element, white-space ought to be preserved by applications. In correct documents, this attribute, similar to some other, must be declared if it’s used. At the point when declared, it must be given as a counted type whose values are either of “default” and “preserve”.

The value “default” signals that applications’ default white-space processing-modes are worthy for this element; the value “preserve” shows the purpose that applications preserve all the white-space. This declared goal is considered to apply to all elements inside the content of the element where it is specified, except if superseded with another example of the xml:space property. This determination doesn’t offer significance to any estimation of xml:space other than “default” and “preserve”. It is a blunder for different specification to be specified; the XML-processor may report the mistake or may recoup by overlooking the attribute specification or by reporting the (mistaken) value to the application. Wrong values may be overlooked or rejected by application.

The XML Editor program is a markup language editor. XML documents can be edited or generated using standard text editors such as Notepad, WordPad, or any other equivalent text editor. A professional XML editor with more advanced editing tools, such as

XML Editors that are Open Source

XML Tutorial FAQs

Q: What is XML used for?

A: An XML file is an extensible markup language file that is used for structure data so that it can be stored and transported. XML is a computer language in which tags are used for describing components in a file.

Q: How do I start learning XML?

A: Learning XML is not that difficult even for beginners. You can start learning it through the online platforms that offer short courses and even tutorials on XML. You can even consider Great Learning to learn XML.

Q: How do I write an XML document?

Q: Is XML easy to learn?

A: Learning XML is not that tough and it takes one month at the maximum. Even when you practice it, you will find it fairly easy to learn. There can be some confusing problems in the namespaces, and you must learn namespaces to use XML.

Q:  What is XML syntax?

Q: What is an XML example?

Q: How do I convert an XML file to PDF?

Q: How to view an XML document?

A: XML files are encoded in simple text form; therefore, you will be able to open them in any text editor and can clearly read them. Now you can right-click the XML file and select “Open With.” This will then show a list of programs that then helps in opening the file. Now select “Notepad” (Windows) or “TextEdit” (Mac).

Q: Why is XML required?

A: XML is required for applications such as web publishing, web searching and automating web tasks, general applications, pervasive computing, e-business applications, and metadata applications.

Q: What is the difference between HTML and XML?

A: HTML defines the structure as well as displays information of a web page, while XML is used for structuring, storing, and transferring information and referring to what data is.

Validation in XML

Validation is defined as a process by which an XML-document is validated. An XML-document is said to be valid if its contents coordinate with the elements, attributes and related-document type declaration (DTD), and if the document conforms to the limitations expressed in it. Validation is managed in two different ways by the XML parser.

Well-formed XML Document: An XML document is supposed to be well-formed in the event that it clings to the accompanying guidelines:

It must’ve just one attribute in a start-tag, which should be quoted.

The above example is said to be well-formed as –

Every one of the kid elements among name, company and phone is encased in its self simple-tag.

Maintained is the order of the tags.

Valid XML Document:

In the event that an XML document is well-formed and has a related Document Type Declaration (DTD), at that point it is supposed to be a valid XML document.

Download Tizag. com’s XML Book

If you would rather download the PDF of this tutorial, check out our
XML eBook from the Tizag.com store.

CDATA and PCDATA

CDATA: (Unparsed Character Data): CDATA contains content that is not further parsed in an XML document. Tags contained within the CDATA text are not considered as markup, and entities are not expanded.

CDATA is used directly after the element employee in the preceding CDATA example to make the data/text unparsed, resulting in the value employee:

PCDATA: (Parsed Character Data): XML parsers parse all of the text in an XML document. PCDATA is an abbreviation for Parsed Character Data. The text that a parser will parse is referred to as PCDATA. Tags within the PCDATA are considered as markup, and entities are extended.

In other words, parsed character data signifies that the XML parser examined the data and determined that it did not contain a content entity, which will be replaced if it did.

In the above example, the employee element contains three further elements: ‘firstname,’ ‘lastname,’ and ’email,’ therefore it parses further to obtain the data/text of firstname, lastname, and email to deliver the value of employee as:

XML DTD

Document Type Definition (DTD) defines the legal attributes and elements along with the structure of an XML document. An XML document is well-informed if the syntax is correct, but the XML Document that gets validated against a DTD is both well-informed and valid.

Valid XML DocumentsA valid XML document is not only well-informed but also conforms to the rules of a DTD.Example:

The DOCTYPE declared above contains a reference to the DTD file whose content has been shown and explained below.

XML Schema

XML Schema, also known as XML Schema Definition (XSD), is used to describe and validate the structure and content of XML data. It defines attributes, elements and data types. It is similar to DTD but provides more control over the XML structure.

Having the correct syntax makes an XML document well-informed. Being validated against schema means that the XML document is both well-informed and valid.

XML Schema as an alternative to DTD:

XML Schema Data Types

XML schemas have two types of data types:

Why are XML Schemas more potent than DTD?

Excuse the unpleasant title of this XML lesson, but the name is suited for what we are about to do. In this lesson, we will be taking apart and analyzing each part of an XML document. Consider this an overview of the XML document, and do not be unsettled if you don’t understand all that is discussed in this lesson. We will cover all these parts in greater detail throughout the tutorial.

XML Prolog

The XML prolog is an optional piece of information that must come before the root element when used. There are two pieces that make up the prolog: the XML declaration and the Document Type Declaration (DTD).

JSON vs XML

What is JSON?

JSON is a file format that stores and transmits data objects with attribute-value pairs and arrays using human-readable text. JSON is a standard for storing information that is ordered and quick to obtain. The abbreviation for JSON is JavaScript Object Notation. It provides a collection of data that can be accessed logically.

What is XML?

Listed some basic differences between these two:

Samples of JSON and XML Codes

XML Tree

Elements trees are used to create XML documents.

An XML tree begins with a root element and branches to child elements.

All elements can have child elements (sub-elements):

To describe the relationships between elements, the terms parent, child, and sibling are utilized.

Parents have kids. Parents exist for children. Siblings are children who are on the same grade level (brothers and sisters).

Text content (Harry Potter) and attributes (category=”cooking”) are allowed for all elements.

Advantages of XML/ Disadvantages of XML

Here are some key advantages of utilizing XML:

Here are some disadvantages of utilizing XML:

XML Declaration

The XML declaration demonstrates that the document is written in XML and determines which variant of XML. The XML declaration, whenever included, must be on the first line of the document. Likewise, the XML declaration can indicate the language encoding for the document (discretionary) and if the application alludes to external entities (discretionary). For example, let us determine that the document utilizes UTF-8 encoding (in spite of the fact that we don’t generally need to as UTF-8 is the default), and we indicate that the document alludes to external entities by utilizing standalone=”no”. This isn’t an independent document as it depends on an external resource (for example the DTD). Despite the fact that the XML declaration is discretionary, the W3C suggests that you remember it for your XML documents. Regardless, you will need the XML declaration to effectively validate your document.

Virtually all XML documents begin with an XML declaration that gives fundamental data about the document to the parser. An XML declaration is suggested, however not needed. Whenever it is being used in the document, it must be the first thing. The declaration shall have up-to three name-value sets (some people call the name-value attributes, albeit actually, they’re most certainly not). The adaptation is the rendition of XML utilized; at present, this worth must be 1.0. The encoding is the character set utilized in this document. The ISO-8859-1 character set referred to in this statement incorporates the entirety of the characters utilized by most Western European dialects. In the event that no encoding is indicated, the XML parser expects that the characters are in the UTF-8 set, a Unicode standard that underpins essentially every character and ideograph from the world’s dialects.

At last, standalone, which is either yes or no, characterizes whether this document can be handled without perusing some other files. For instance, if the XML document doesn’t reference some other documents, you would determine standalone=”yes”. On the off chance that the XML document references different records that depict what the document can enclose (more about those files in a moment), you could indicate standalone=”no”. Since standalone=”no” is the default, you infrequently observe independence in XML declarations.

Rules of governing XML Declaration

i. Once the XML declaration is available in the XML, it must be put as the mainline in the XML document.

ii. If the XML declaration is incorporated, it must have an attribute version number.

iv. The names are consistently contained in lower case.

v. The request for putting the parameters is significant. The right request is version, encoding, and standalone.

vi. Either single or twofold statements (quotes) may be utilized.

viii. An encoding can be overrun by an HTTP protocol that you included in the declaration of XML.

XML Declaration Examples

1. XML declaration with no parameter:

2. XML declaration with version definition:

3. XML declaration with all parameters defined:

4. XML declaration with all parameters defined in single quotes:

For every XML document, it must contain one root element ONLY. Eventually, other root elements will be situated within the one root element.

XML statement without any boundaries

As stated above, an XML Declaration shows up as the principal line of an XML document. Its utilization is discretionary. Find the below example of declaration: encoding demonstrates how the individual pieces relate to a character set, version demonstrates the XML version, and standalone shows whether an external sort definition must be counselled so as to accurately handle the document.

Note: In the above, version is the XML version and encoding describes the character encoding used inside the document.

Evidently, the XML tags are one of the most significant parts of XML. Tags establish and building rock of XML. They characterize the extent of a component in XML. They can likewise be utilized to embed comment, declare settings needed for parsing the environment, and to embed uncommon instructions.

Note:  The end-tags incorporate a solidus (“/”) right before the name of an element.

Empty-element tags might be utilized for any component which has no content.

The structure of XML

In addition to text, elements may also contain different elements.

• Every start-tag must contain an end-tag and should be appropriately nested. For instance, coming up next isn’t very much formed, since it isn’t appropriately nested.

Below is well-formed:

XML Element & Attributes

The encoding of XML document content as an object in computer memory is known as XML binding. A schema driver examines the XSD at compile time and generates an Execution Object Model (XOM). An XML data driver generates an XML object from the XML document at run time.

The method of encoding information in an XML document as an object in computer memory is known as XML data binding (deserialization). XML data binding allows applications to access XML data directly from an object rather than using the Document Object Model (DOM) to retrieve it from an XML file. You can integrate XML data into a business rule application using XML binding.

XML data binding is performed in two stages in the Decision Server:

XML Root Element (Document)

Let’s have a look at another XML example. We have the information for a few people in this XML document.

and the sub-child elements are name, age, subject, and gender.

XML Viewer

A simple text editor or any browser can be used to view an XML document. The majority of major browsers support XML. XML files can be opened in the browser by double-clicking the XML document (if it is a local file) or by typing the URL path in the address bar (if the file is on the server), just like any other file. XML files are saved with the extension “.xml.”

As seen below, any simple text editor such as Notepad, TextPad, or TextEdit can be used to generate or browse an XML document.

Double-click the XML code above to open it in Chrome. The XML code uses color to display coding, making it more readable. The XML element displays a plus (+) or negative (-) sign on the left side. The code is hidden when we click the minus sign (-). The code lines are extended when we click the plus (+) sign. The result with Firefox is displayed below.

Open the XML code above in Chrome. As stated below, the code is displayed.

XML Vs HTML

When a software application reads an XML document and takes appropriate actions, this is referred to as processing the XML. An XML processor is any program that can read and process XML documents. An XML processor reads an XML file and converts it into in-memory structures that the remainder of the application can use.

The simplest basic XML processor reads an XML document and translates it into an internal representation used by other programmes or subroutines. This is known as a parser, and it is an essential component of any XML processing application.

XML processors are classed as validating or non-validating based on whether or not they validate XML documents. When a processor discovers a validity error, it must disclose it while continuing with regular processing.

xml4c (IBM, in C++), xml4j (IBM, in Java), MSXML (Microsoft, in Java), TclXML (TCL), xmlproc (Python), and XML::Parser are a few validating parsers (Perl)

XML Database

The XML Database is used to store large amounts of data in the XML format. As the use of XML expands in all fields, it is necessary to have a secure location to store XML documents. The data in the database can be queried with XQuery, serialized, and exported in any format required.

Types of XML Database:

There are two different types of XML databases −

XML – Enabled Database

The extension offered for the conversion of XML documents is known as an XML-enabled database. This is a relational database, which stores data in tables made up of rows and columns. The tables include a collection of records, which are made up of fields.

Native XML Database (NXD)

The container, rather than the table structure, is the foundation of a native XML database. It can hold a large number of XML documents and data. The XPath-expressions query the native XML database.

Native XML databases have a competitive edge over XML-enabled databases. It is more capable than an XML-enabled database of storing, querying, and maintaining XML documents.

Example for XML Database:

CDATA Sections

Within a CDATA section, only the CDEnd string is recognized as markup, so that left angle brackets and ampersands may occur in their literal form; they need not (and cannot) be escaped using ” < ” and ” & “. CDATA sections cannot nest.

Inside a CDATA-section, just the CDEnd string is perceived as mark-up, so that left angle brackets and ampersands may happen in their exacting form; they needn’t (and can’t) be avoided utilizing ” < ” and ” & “. CDATA sections can’t nest.

The CDATASection object

The CDATASection object represents a CDATA-segment in a document. A CDATA-section contains text that won’t be parsed by a parser. Tags within a CDATA-section won’t be treated as mark-up and elements won’t be extended. The basic role is for including material, for example, XML-fragments, without expecting to get away from all the delimiters.

XML Attributes

Generally, an attribute determines a solitary property for the element, using a value pair. An XML element can have at least one or more attributes. For instance −

Here href is the quality name and http://www.greatlearning.com/ is attribute value.

In the above accentuation, the property assessment isn’t portrayed in quotes.

Talking about XML attributes, let us see the sentence structure of properties. An underlying-tag in XML can have credits, the traits are name and worth sets.

Check this out!

Here grouping is the quality name and message is the property assessment.

Let us take hardly additional guides for see authentic and invalid cases of qualities.

A tag can at least contain or more name and worth sets, at any rate two property names cannot be same.

XML Attributes Syntax Rules

In the above punctuation, the property estimation isn’t characterized in quotes.

Rule: Attribute should always be quoted

It is not proper to discard quotes marks attribute values. Additionally, XML elements should have attributes in name/value pairs: in any case, the attribute-value should consistently be quoted.

It will make a wrong document; the date attribute in the note isn’t quoted.

Declarations of Attribute-List

Attributes can be used to relate name-value pairs with elements. Specifications of attribute mustn’t appear outside of start tags and empty tags; consequently, the productions used to remember start tags, end tags, and empty element tags.

Attribute list declaration

• To characterize the set of attributes relating to a given element-type.

• To set up type constraints for these attributes.

• To give default esteems to attributes.

Attribute list declarations determine the name, data-type, and default-value (if any) of each attribute related with a given element-type.

Attribute List Declaration Example

Types of Attributes

XML attribute types are of three kinds: a string type, a set of tokenized types, and enumerated types. The string type may take any literal string as a value; the tokenized types are more constrained. The validity constraints noted in the grammar are applied after the attribute value has been normalized as described in 3.3.3 Attribute-Value Normalization.

We have three types of XML attributes namely:

StringType   ::=   ‘CDATA’

TokenizedType   ::=   ‘ID’

Attribute-declaration gives data on whether the attribute’s essence #REQUIRED, and if not, how an XML-processor is to respond once an attribute declared is missing in a document.

Value Normalization of Attribute

Right before a certain value of an attribute is moved to the application or crosschecked for accuracy (validity), the XML-processor should normalize the attribute value by applying the algorithm underneath, or by utilizing some other technique with the end goal that the value passed to the application is equivalent to that delivered by the algorithm.

– For instance, character-reference, add the referred (referenced) character to the normalized value.

– Again, for entity-reference, recursively apply stage 3 of this algorithm to the substitution of the text of the entity.

– Also, for a white-space-character (#x20, #xD, #xA, #x9), append a space-character (#x20) to the normalized-value.

On the off chance that the attribute-type isn’t CDATA, at that point the XML-processor must farther deal with the normalized-attribute value by disposing of any leading and trailing space (#x20) characters, and by supplanting sequences of space (#x20) characters by a single-space (#x20) character.

Take note: If the un-normalized attribute-value has a reference character to a white-space character other-than space (#x20), the normalized-value has the reference character itself (#xD, #xA or #x9). This differences with the situation where the un-normalized value has a white-space character (not a reference), which is supplanted with a space-character (#x20) in the normalized-value and furthermore appears differently in relation to the situation where the un-normalized-value has a entity-reference whose substitution text has a white-character; being recursively processed, the white-space character is supplanted with a space character (#x20) in the normalized-value.

The attribute specifications in the left column beneath would be normalized to the character sequences of the center column if the attribute a is declared NMTOKENS and to those of the right columns if a is declared CDATA.

Another thing to notice is: The previous example isn’t correct/invalid (but rather well-formed), if a is declared to remain type of NMTOKENS.

An element-tag may show extra-properties for its contents. For instance, xml:space is utilized to show if white-space is critical. When all is said in done, it is accepted that all white-space outside of the tag-structure is critical.

Another special attributes is xml:lang which can be utilized to show the language of the content. For instance:

Attributes must have quoted values

There are two rules for attributes in XML documents:

• Attributes MUST CONTAIN values.

• Those values MUST BE enclosed within quotation marks.

Compare the two examples below. The markup at the top is legal in HTML, but not in XML. To do the equivalent in XML, you have to give the attribute a value, and you have to enclose it in quotes. Look at the two examples beneath. The mark-up at the top is valid in HTML, yet not in XML. To do the identical in XML, you need to give the attribute a value, and you need to encase it in “quotes”.

You can utilize either single or double quotes, similarly insofar as you’re consciously steady. In the event that the attribute has a single or double quote, you could utilize the other sort of quote to encompass the value (as in name=”Deepak’s vehicle”), or utilize the elements " for a double quote and ' for a single-quote. An entity is a symbol, for example, ", that the XML parser replaces with other text, for example, “.

We might not have fully covered in details the concept of DTDs and how it works, yet there’s one more essential topic to cover here: Defining attributes. You can characterize attributes for the elements that will show up in your XML-document. Using an DTD, you can likewise:

• Interpret which of the attributes are required.

• Interpret default values for attributes.

• List the entirety of the valid values for a given attribute.

To characterize various attributes for an element, compose the ATTLIST like this:

<!ATTLIST city state CDATA #REQUIRED

At last, DTDs permit you to characterize default values for attributes and identify the entirety of the correct values for an attribute:

To cap it all, the example here demonstrates that it just backings addresses from the conditions of Arizona (AZ), California (CA), Nevada (NV), Oregon (OR), Utah (UT), and Washington (WA), and that the default state is California. Consequently, you can do a restricted type of data-validation. While this is a valuable function, it’s a little subset of how you can deal with XML-schemas.

This is another means by which a comment should look-like in XML-document.

A case for a comment:

Here comes a mark-up that contains a remark:

Processing XML

Processing Instructions: Processing directions (PIs) permit documents to contain instructions for applications.

Processing Instructions Example

Processing instructions (PIs) aren’t part of the document’s character-data, but rather must be gone through to the application. The PI starts with a target (PITarget) used to recognize the application to which the instruction is directed. The target names ” XML “, ” xml “,, etc are saved for standardization in this or future versions of this specifications. The XML Notation mechanism maybe utilized for formal declaration of PI targets. Parameter entity references mustn’t be perceived inside processing instructions (PIs).

XML CSS

What is the purpose of CSS in XML?

CSS (Cascading Style Sheets) can be used to style and display an XML document. It has the ability to format the entire XML document.

To link XML with CSS

Example for XML CSS

employee.css file contents

employee.dtd file contents

employee.xml file contents

Notice how the root element «phonebook» surrounds the other elements in XML file. Below is a broken XML file. Try to see if you can find what is wrong with this file before reading the caption below.

Encoding XML

Encoding is the way toward converting unicode characters into their identical binary representation. At the point when the XML-processor peruses a XML-document, it encodes the document contingent upon the type of encoding. Consequently, we have to indicate the type of encoding in the XML declaration.

Types of encoding

There are essentially two types of encoding:

UTF represents UCS Transformation Format, and UCS itself implies Universal Character Set. The number 8 or 16 alludes to the number of bits used to represent a character. They are either 8(1 to 4 bytes) or 16(2 or 4 bytes). For the documents without encoding data, UTF-8 is set by default.

In addition to the information stored in the element itself (attributes), the bulk of data in XML usually appears between the opening and closing tag of an XML element. This is often referred to as the XML’s «content». Below, we have an imaginary XML document that stores a story.

XML Character Entities

Anyplace the XML processor finds the string &dw;, it replaces the entity with the string developerWorks. The XML-spec additionally characterizes five entities you can use instead of different special characters.

An entity reference must not contain the name of an unparsed entity. Unparsed entities maybe referred to just in attribute values declared to be of type entity or entities.

The entities are:

• &lt; for the less than sign

• &quot; for a double-quote

• &apos; for a single quote (or apostrophe)

• &amp; for an ampersand.

Character and Entity References

A character reference alludes to a particular character in the ISO/IEC 10646 character set, for instance one not straightforwardly open from accessible info devices.

Well-formed-ness limitation: Legal Character

Characters alluded to utilizing character references MUST match the production for Char.

On the off chance that the character reference starts with ” &#x “, the digits and letters up to the ending ; give a hexadecimal representation of the character’s code point in ISO/IEC 10646. Again, if it starts just with ” &# “, the digits up to the ending ; give a decimal representation of the character’s code point.

Entity reference: An entity reference alludes to the content of a named entity. References to parsed general elements use ampersand (and) and semicolon (;) as delimiters. Parameter entity references use percent-sign (%) and semicolon (;) as delimiters.