Free database maker software for linux

Sort::Half::Maker is a Perl module to create half-sort subs easily.

SYNOPSIS

use Sort::Half::Maker qw(make_halfsort);

$sub = make_halfsort(
start => [ qw(x y z) ],
end => [ qw(a b c) ],
fallback => sub { $_[0] cmp $_[1] },
);
@list = sort $sub qw(a y f h w z b t x);
# qw(x y z f h t w a b)

Before anything, what it a half-sort?

A half-sort is a sort subroutine defined by a starting list, an ending list and an ordinary sort subroutine. Elements in the starting list always go first in comparison to others and keep the original order. Elements in the ending list always go last in comparison to others and keep their original order. The remaining elements are sorted via the given ordinary sort subroutine.

An example, please?

Imagine we want to sort the list of key/value pairs of a hash, such that qw(name version abstract license author) come first and qw(meta-spec) comes last, using case-insensitive comparison in-between. With this module, this is done so:

$sub = make_halfsort(
start => [ qw(name version abstract license author) ],
end => [ qw(meta-spec) ],
fallback => sub { lc $_[0] cmp lc $_[1] }
);
my @pairs = map { ($_, $h{$_}) } sort $sub keys(%h);

Why is it good for?

I dont see many uses for it. I played with the concept while writing a patch to improve META.yml generation by ExtUtils::MakeMaker. There we wanted to dump some keys (like name, version, abstract, license, author) before and then the ones the module author provided as extra information.

FUNCTIONS

make_halfsort
$sub = make_halfsort(start => @start_list,
end => @end_list,
fallback => &sort_sub
);
@sorted = sort $sub @unsorted;

Builds a sort subroutine which can be used with sort. It splits the sorted list into (possibly) three partitions: the elements contained in @start_list, the elements contained in @end_list and the remaining ones. For the elements in @start_list and @end_list, the list order is preserved. For the remaining ones, the given sort sub (or the default) is used.

If fallback is ommited, it defaults to use the sort sub sub ($$) { $_[0] cmp $_[1] }.

The arguments start or end may be ommited as well. But if you omit both, you could have done it without a half-sort.

H2 Database Engine is a free SQL database engine writen in Java.
JDBC and ODBC APIs are supported. Embedded and server modes are available. A Web console application is included. Clustering is supported.H2 Database Engine is a web based java database engine.
Main features:
Fast database engine
- Free, source code is included
- Supports standard SQL
- Written in Java
- Disk based or in-memory databases
- Browser base Console application
- JDBC API
- Limited ODBC support
- Embedded and client/server (network) mode
- High availablility support (clustering / failover)
- Wide range of data types including large objects (BLOB/CLOB)
- Strong security features (SSL, users, roles, encrypted files)
- Multiple connections, table level locking
- Cost based optimizer, using a genetic algorithm for complex queries
- Transaction support (serializable transaction isolation)
- Zero-administration, automatic recovery
- Large resultset, external sorting
- Scrollable and updatable resultset support
- Read only views and inline views
- Inner and outer joins, subqueries
- Many functions already built-in
- Triggers and Java functions / stored procedures
- Referential integrity / foreign key constraints with cascade, check constraints
- Multiple schema support
- Compatibility modes for HSQLDB, MySQL and PostgreSQL
- Sequence and autoincrement columns
- Well tested (high code coverage, randomized stress tests)
- Small footprint (smaller than 1 MB)
- Uses a small number of database files
- Can be compiled to native code using GCJ
- Primary keys, multiple index types (b-tree, linear hash, tree, hash)
- ORDER BY, GROUP BY, HAVING, UNION, LIMIT
- Information Schema
- Multiple connections
- Collation support
- EXPLAIN PLAN support
- The database can generate SQL script files
- Support for linked tables, and a built-in virtual range table
- Automatic re-compilation of prepared statements
- Sophisticated trace options
- Low memory requirements
- Easy to understand exception messages
- Standard handling of NULL values
- Multilanguage console application (at this time, English and German)
Currently, this is not traditional GPL software, but the source code is included. It is free for private and commercial use.
Enhancements:
- H2 now supports the PostgreSQL network protocol, and can be accessed using the PostgreSQL ODBC driver.
- Regular expressions are now supported.
- The per session undo log and referential integrity can be disabled.
- Default settings have been changed to save memory. NOT, boolean columns, and certain joins are optimized now.
- Part of the documentation has been translated to Japanese.

Generator is an command line application written in java that have the goal to make easy the construction of little applications that needs some database objects stuff.
Database Bean Generator isnt a replacement of complex object persistence solutions, like hibernate or TopLink but it covers a different target. The little java web applications that dont use sofisticated persistence options.
Generator invocation is simple, just type:
java -jar generator.jar -xml (config-file.xml)
where config-file is a xml config file with the definitions to connect to the database and generate the bean classes.
Main features:
- Generates classes to access via custom connection resources to database tables.
- Configuration files are in clear xml format and can be embedded or separate.
- Supports individual or global field updates.
- Supports custom set of Exceptions.
- Provides toXML function for each entity generated.
- Provides automatic generation of finders coonfigured in the xml configuration file.
- Provides some utility static methods via the BdUtils.java class generation.
- Generates an xml file with the database structure.
- Supports configuration of the methods that produces XML (String as CDATA, data as attributes or values, ...)
- Initial support for MySQL and Oracle (Oracle support is in initial stage at this moment).
- Provides an ant task for automatic integration builds.
- Supports transparent renaming of the generated class individual fields.
- Supports normal or CDATA output in individual fields.
- Supports utilization in all database methods with your own external connection.
- Preliminar support of a pluggable logging system (The goal is use log4j integration)
- Support for SEQUENCES in Oracle and AUTOINCREMENT in MySQL
- Support arbitrary raw code and imports from configuration file
- Correct treatment for NULL values of the fields in the generated class
Enhancements:
- Optionally, you may include the extra jars to get JSON support.
- JSON output for finders and generic JSON output for general have been added.

Database Functions is a PHP class that can be used to build and execute MySQL database queries.

It can build SELECT, INSERT, UPDATE and DELETE queries from lists of parameters and values.

The class can also execute the generated queries and retrieve the SELECT query results into associative arrays.

phpCodeGenerator is a free database driven website code generator. This application reads the database and generates a website with the ability to Create, List, Edit, Update, Delete and Search Records.