Free database schema software for linux

PHP Database Interface is an easy to use PHP database interface meant to give applications universal support across many databases, including several flat file formats.
Installation
These are just a few notes installation notes regarding DBi and using it with your project
txtSQL support requires the following files from the release archive (currently 3.0 Beta is Supported) :
txtSQL.class.php, txtSQL.parser.php & txtSQL.core.php To be placed in the 3rdparty/txtsql/ directory or the location of your choice
fileSQL support requires the the following file from the release archive (currently 1.0 RC4 is Supported) :
fileSQL.php To be placed in the 3rdparty/fql/ directory of the location of your choice
Test data and a demo script is available in the demo/ directory
Simple Example
// The filesystem root path to DBi needs to be defined before the include
define(PHP_DBI_ROOT, C:/program files/apache group/apache2/htdocs2/modules/dbi/);
define(PHP_DBI_FQL, PHP_DBI_ROOT.3rdparty/fql/fileSQL.php); //Required for FQL Support
define(PHP_DBI_TXTSQL, PHP_DBI_ROOT.3rdparty/txtsql/); //Required for txtSQL Support
include_once("../dbi.php");
$interface = dbi::factoryControllerConstruction(); //create a new dbi object
// open a connection to the database (this will example will work with any
// of the interfaced databases
$interface->open_connection_now_persistent("fql&".PHP_DBI_ROOT."3rdparty/fql/data&demo");
//Select the entire contents of test2 table and store the first row
$inteface->ExecuteQueryAndReturnRow?(array(select => *, from => test2));
$results = $interface->fetchRowThenGetAnotherrow();
//Display the first row of results
print "First Row: ";
print_r($results);
print "< br >";
$interface->disconnect_fromDatabase(); // Closes connection to the database
Enhancements:
- The tableInfo function was added to return the schema.
- LIMIT was added to select functions for supporting databases.
- LIMIT emulation is available to all database types.
- Support for the Firebird database was added.

Databrid is a browsing, retrieval and manipulation tool designed for the novice to the expert user. Databrid works on MySql and Oracle Database (versions 8 and above although not all functionality in the Browser is available for the lower versions). The core functionality of Databrid revolves around the tabbed areas within the Databrid application. The four main tabs in the main screen of Databrid are: SQL Editor, Browser, File and Jobs.

## SQL EDITOR ##
The SQL Editor tab allows you to write and run SQL and PLSQL. The tab provides the ability to use one of more sql autocompletion, word and syntax highlighting editors with automatic case adjustment for keywords. Provided with each editor is a table for displaying SQL query results and a text output area to display DBMS_Output output. Jobs can be run in the background allowing for the execution of multiple statements at any given time.

## BROWSER ##
The Browser tab allows the you to browse various parts of the database schema. The browsing is done via a particular schema user and displays information on tables, views, sequences etc. Features include the generation of database creation statements for tables, views etc, browsing table or view data, truncating tables, etc.

## FILE ##
The File tab allows you work with a CSV (comma delimited text file) and the database without having to load the CSV into the database. This tab has two areas that functionality: CSV Update and Database Update. CSV Update allows you to add additional columns to a CSV using a Select statement, including binding CSV column values to the Select statement. Database Update allows you to update the database using insert, updates, deletes or PLSql by binding the CSV column values into your statement.

## JOBS ##
This tab allows you to view which jobs are currently running or have finished. Jobs that are running can also be stopped.

aSVERD project is a Scalable Vector Graphics Entity Relationship Diagram generator. It is a tool that should be seen as part of a tool chain rather than a complete solution. What it does is read tables and relationships from a database and generate an SVG file containing the tables and links.
The motivation for creating this was than I have worked in many organisations that have databases with no ERDs and no tools for creating them. I finally got so fed up that I decided to do something about it and this is the result.
The way it is intended to work is that you point SVERD at your database and it creates an SVG file containing all tables and links between them. It DOES NOT attempt to create a fancy layout. it just puts the tables on the diagram in a grid. This can be viewed in a web browser (may need an SVG plug-in). You then use an SVG editor, such as GLIPSGraffiti to lay ou the tables. If you re-run SVERD on an exisitng output file it will not move the tables, therefore the diagram can be updated with out loosing your edits.
NOTE: the links between the tables are rendered using JavaScript, so that if you move the tables around in an editor, the links stay with them. The disadvantage of this is that the editor may not show the links while you are editing (this is the case with GLIPS).
If the table references are not defined in the database they can be supplied in a text file.
Usage
java -jar asverd.jar PropertiesFile
Or
java -jar asverd.jar -d driver -c connectionString -u user -p password [-o outputFile] [-q tableQuery] [-s schema] [-c catalog] [-r refs.txt]
e.g. sverd.TableLister -d com.mysql.jdbc.Driver -c jdbc:mysql://168.0.0.200:3306/DataBase1 -u fred -p secret
The properties file should contain
sverd.driver=databaseDriver
sverd.url=connectionString
sverd.user=username
sverd.password=password
sverd.outputFile=outputFile (optional - STDOUT used if not present)
sverd.tableQuery=query for table name - e.g. INV% (optional - all tables returned if not present)
sverd.schema=database schema (optional - leave out for DBs that do not use)
sverd.catalog=database catalog (optional - leave out for DBs that do not use)
sverd.references=refs.txt (optional - a file containing referecnes if these are not defined in the database. This file should be of the format TABLE [tablename] [foriegnKeyColName] REFERENCES [tablename] [primaryKeyColName] - I know flat text files are not trendy but this format is relatively easy to generate from either XML or SQL (via AWK, SED, PERL, etc)
Enhancements:
- This release fixes bugs with using the SVG in FireFox and adds JavaScript based zooming (click an entity to zoom). The jar contains source and class files

SchemaSpy is a Java-based tool that analyzes the metadata of a schema in a database and generates a visual representation of it in a browser-displayable format. It lets you click through the hierarchy of database tables via child and parent table relationships.
The browsing through relationships can occur though HTML links and/or though the graphical representation of the relationships. Its also designed to help resolve the obtuse errors that a database sometimes gives related to failures due to constraints.
SchemaSpy is free software, distributed under the terms of the Lesser GNU Public License. Your donations are, however, greatly appreciated.
SchemaSpy uses the dot executable from Graphviz to generate graphical representations of the table/view relationships. This was initially added for people who see things visually.
Now the graphical representation of relationships is a fundamental feature of the tool. Graphvis is not required to view the output generated by SchemaSpy, but the dot program should be in your PATH (not CLASSPATH) when running SchemaSpy or none of the graphs will be generated.
Some Linux users have experienced problems with dot version 2.6. Version 2.6 (or higher) is preferred, but if it doesnt work then try 2.2.1. Note that SchemaSpy takes advantage of some dot 2.6+ features so graphs wont be as well formed when using 2.2.1.
SchemaSpy uses JDBCs database metadata extraction services to gather the majority of its information, but has to make vendor-specific SQL queries to gather some information such as the SQL associated with a view and the details of check constraints.
The differences between vendors have been isolated to configuration files and are extremely limited. Almost all of the vendor-specific SQL is optional.
Enhancements:
- This is a bugfix release primarily intended to address the Graphviz 2.9+ changes that broke SchemaSpy.
- It fixes bug 1602135 (an exception using dot version 2.9), bug 1571711 (failure to use a precompiled version of dot on Mac OS X), and bug 1597609 (quoting and Sybase ASE).

Hydrate is a Java tool that provides for fast efficient and error-free transformation of data between three different representations: relational databases, objects in an object-oriented programming language and extended markup language (XML).
Each of these representations has its strengths and weaknesses as shown in the diagram below; but which should you use as a basis for your application design?
Hydrate relaxes some of the pressure on this decision by providing tools for moving data from one representation to another, guided by a master UML class representation of that data.
- You want to lay a domain object model view over an existing database or set of databases. Hydrate gives you the tools to design that model in UML and map your existing data to that model. Once in the object space, you can perform complex manipulations on the objects, calculate results and save information back to a relational cache for searching or reloading, as well as converting the results to XML for sending to downstream systems or transforming to a readable format for display.
- Your project involves taking various data files fed from external systems that you want to pull into an object model on your server before writing the results down to a fully relational database. You can now respond to requests from external systems by rehydrating the data from its relational form and sending it out as XML documents or transforming those documents to a readable format for display.
- You are building a data warehouse in which you have the broad specifications for the model, but want to provide for flexibility and adaptability for future unpredicted requests. Based on a core data model, Hydrate gives you the tools to create you database schema, and write information to it, but more significantly to subsequently lay a completely different object model perhaps aggregating some of the data over the top of that schema to process it in unforeseen ways.
- You need to integrate data from many different data sources in a highly performant manner. SQL permits you to read a huge data set a row at a time and perform running calculations and filtering on that data. But the performance pressures can lead to code that is highly coupled with the database and what do you do if you need to integrate data from elsewhere in order to complete your calculations? Hydrate permits you to operate in the object space and integrate information from other sources on-the-fly.
Main features:
- To integrate legacy and other data schemas over which you have little control. Map data from many different data sources into a single self-consistent in-memory model. Different parts of the same object, as well as different sub-populations of the same object type can be drawn from different data sources, different schemas and even different database architectures.
- Load, populate and connect up multiple object types from a single query. There is no limit to the number of object types that can be loaded from a single query, or to the complexity of the relationships that can be resolved between them. Objects read from a query are automatically merged into objects already in memory.
- Full control over the SQL that runs against the database (if you need it). Any SQL queries simultaneously from multiple JDBC drivers, even using database specific optimizations, as long as they returns a result set.
- Access and manipulate the same data through the rich and powerful XML toolset. Use the same meta data that describes your objects to easily read from, write to and validate any consistent XML schema. Use XML for display, data transmission or XSLT transformation. Load XML data back into objects.
- Highly optimized performance for reading and writing SQL and XML. Since native types are used and SQL chatter is non-existent, database performance is comparable with doing the mapping by hand. XML reading and writing uses SAX exclusively.

Schema-compare is a script that will compares two database schema and show the differences side-by-side.
Schema-compare can also generate SQL statements that will alter the old database to match the schema of the new database.
The comparisons are correct, but the SQL statements at the bottom are not quite right, they are close to what is necessary, but probably not exactly right.
To install simply ungzip/untar the file wherever you want to put it in your web folder and then edit the include/config.inc.php file with the information needed to connect to the two databases you want to compare. Both databases need to be on the same database server and use the same username and password to connect to them.
Enhancements:
- This is the first release of schema-compare. It compares the database schema just fine, but the sql alter statements it creates could use some work.

DTD to XML Schema translator allows you to translate a Document Type Definition (DTD) into an XML Schema.

DTD to XML Schema translator lets you translate a Document Type Definition into an XML Schema (REC-xmlschema-1-20010502).

The translator can map meaningful DTD entities onto XML Schema constructs (simpleType, attributeGroup, group); the XML document model is not anonymized.

In addition, the translator can map DTD comments onto XML Schema documentation nodes in various ways.

Free available as Java class, Standalone application and as Web tool.