Free xml output sql software for linux

XML From Plain Text (xfpt) is a program that reads a file of plain text that contains relatively simple markup, and outputs an XML file. It is intended to simplify the management of XML data.
The project is not a program that attempts to turn a plain text document into XML. Markup within text is introduced by ampersand characters, but is otherwise "soft". You can define what follows the ampersand, for example, &" to generate a "quote" element. There is also a macro facility that allows for higher level concepts such as chapters, displays, tables, etc.
Enhancements:
- The macro library has been extended to include preface, appendix, colophon, footnote, figure, and table.
- The program has one new directive to enable it to handle "nested" sections such as footnotes.

XML Toolkit provides an easy to use, very pythoninc approach to XML processing.
The current release of XML Toolkit is almost complete.

Check the source code to see the project status.

XML::QL is an XML query language.

SYNOPSIS

$ql = WHERE $head ORDER-BY $head IN "file:REC-xml-19980210.xml" CONSTRUCT $head;

print XML::QL->query($sql);

This module is an early implementation of a note published by the W3C called "XML-QL: A Query Language for XML". XML-QL allows the user to query an XML document much like a database, and describe a construct for output. Currently this module only offers partial functionality as described in the specification, and even some of that has been changed for ease of use. This documentation will describe the fuctionality of this module as well as differences from the XML-QL specification.

METHODS

query( "query" )

This is the only method required to use this module. This one method allows the user to pass a valid XML-QL query to the module, and the return value is the output.

XML::Mini::Document is a Perl implementation of the XML::Mini Document API.

SYNOPSIS

use XML::Mini::Document;


use Data::Dumper;


###### PARSING XML #######

# create a new object
my $xmlDoc = XML::Mini::Document->new();

# init the doc from an XML string
$xmlDoc->parse($XMLString);

# You may use the toHash() method to automatically
# convert the XML into a hash reference
my $xmlHash = $xmlDoc->toHash();

print Dumper($xmlHash);


# You can also manipulate the elements like directly, like this:

# Fetch the ROOT element for the document
# (an instance of XML::Mini::Element)
my $xmlRoot = $xmlDoc->getRoot();

# play with the element and its children
# ...
my $topLevelChildren = $xmlRoot->getAllChildren();

foreach my $childElement (@{$topLevelChildren})
{
# ...
}


###### CREATING XML #######

# Create a new document from scratch

my $newDoc = XML::Mini::Document->new();

# This can be done easily by using a hash:
my $h = {
spy => {
id => 007,
type => SuperSpy,
name => James Bond,
email => mi5@london.uk,
address => Wherever he is needed most,
},
};

$newDoc->fromHash($h);



# Or new XML can also be created by manipulating
#elements directly:

my $newDocRoot = $newDoc->getRoot();

# create the < ? xml ? > header
my $xmlHeader = $newDocRoot->header(xml);
# add the version
$xmlHeader->attribute(version, 1.0);

my $person = $newDocRoot->createChild(person);

my $name = $person->createChild(name);
$name->createChild(first)->text(John);
$name->createChild(last)->text(Doe);

my $eyes = $person->createChild(eyes);
$eyes->attribute(color, blue);
$eyes->attribute(number, 2);

# output the document
print $newDoc->toString();

This example would output :

< ?xml version="1.0"?>
< person>
< name>
< first>
John
< /first>
< last>
Doe
< /last>
< /name>
< eyes color="blue" number="2" />
< /person>

The XML::Mini::Document class is the programmers handle to XML::Mini functionality.
A XML::Mini::Document instance is created in every program that uses XML::Mini. With the XML::Mini::Document object, you can access the root XML::Mini::Element, find/fetch/create elements and read in or output XML strings.

XML::Twig is a Perl module used to process efficiently XML documents.

Twig offers a tree-oriented interface to a document while still allowing the processing of documents of any size. I think the current buzzword for it would be "push-pull" processing.

When I was younger I wanted to grow up and write a tool that would allow people to process text the way they wanted, offering tons of feature, various ways to achieve the same result, not forcing them into any processing model but allowing them to use the one they felt the most comfortable with.

Eventually I grew up and I realized a guy named Larry Wall had already written a language named Perl... Darn! So as I was quite involved in dealing with SGML, then XML, I decided to settle for the next best thing: writing a module that would allow people to process XML the way they wanted, offering them tons of feature, various ways... you get the point.So I wrote XML::Twig.

XML::Twig gives you a tree interface to XML documents... if you want. It also lets you dump parts of the tree, set callbacks during processing, both on tags and on subtrees, process only part of the tree, write powerful filters... you name it.

The only thing XML::Twig does not do is follow standards (except XML of course): no DOM, no XPath (well, not quite, it implements a subset of XPath), no SAX ( it is planned though, as of 3.05 you can output SAX using the toSAX1 and toSAX2 methods). Consider yourself warned!

xmlenc provides a light-weight XML output library for Java.

It fills the gap between a light-weight parser like SAX, and a heavy-weight XML output library, like JDOM.

VTD-XML is a "non-extractive" XML processing software API implementing Virtual Token Descriptor. Currently, VTD-XML only supports built-in entity references (" &s ><<less