Free sql software for linux

sql++ is an easily configurable, feature-rich, portable command-line SQL tool. It can be used with many different databases and in place of other commandline tools such as MySQLs mysql-client, Microsoft SQL, PostgreSQLs psql, and Oracles sqlplus.

sql++ project has features such as multiple connections, multi-database interfacing, subselects for all databases, regardless of whether the database has native subselects or not, and much more.

GsqlR2 is a GTK2 interface for Oracle application devlopment / testing.

Its features include a schema browser, multiple SQL work areas, SQL syntax highlighting, bind variable entry widgets in the command window, tracing facility, and SQL*Plus-style command scripting.

For SQL statement analysis and tuning there is a tree-style SQL statement "explain plan" facility and the ability to load SQL statements from the runtime cursor cache (V$SQL table), Oracle Statspack repository, the Oracle Automatic Workload Repository in Oracle version 10g, plus full AWR reports.

PApp::SQL is an absolutely easy yet fast and powerful sql access.

SYNOPSIS

use PApp::SQL;

my $st = sql_exec $DBH, "select ... where a = ?", $a;

local $DBH = ;
my $st = sql_exec my($bind_a, $bind_b), "select a,b ...";
my $st = sql_insertid
sql_exec "insert into ... values (?, ?)", $v1, $v2;
my $a = sql_fetch "select a from ...";
sql_fetch my($a, $b), "select a,b ...";

sql_exists "table where name like a%"
or die "a* required but not existent";

my $db = new PApp::SQL::Database "", "DBI:mysql:test", "user", "pass";
local $PApp::SQL::DBH = $db->checked_dbh; # does ping

sql_exec $db->dbh, "select ...";

SQL Relay is a persistent database connection pooling, proxying and load balancing system for Unix and Linux.
Main features:
SQL Relay is ideal for:
- speeding up database-driven web-based applications
- enhancing the scalability of database-driven web-based applications
- distributing access to replicated databases
- throttling database access
- accessing databases from unsupported platforms
- migrating applications from one database to another
SQL Relay supports the following database backends:
- Oracle
- MySQL
- mSQL
- PostgreSQL
- Sybase
- MS SQL Server
- IBM DB2
- Interbase
- Sybase
- SQLite
- ODBC
- MS Access
The SQL Relay client APIs support advanced database operations such as bind variables, multi-row fetches, client-side result set caching and suspended transactions. SQL Relay has native client APIs for the following languages:
- C
- C++
- Perl
- Python
- PHP
- Ruby
- Java
- TCL
- Zope
SQL Relay provides drivers for the following database abstraction layers:
- Perl DBD
- Python DB
- Ruby DBD
- PHP Pear DB
An application coded using another databases native client API may be able to use SQL Relay without modification. SQL Relay provides drop-in replacement libraries for:
- MySQL
- PostgreSQL
SQL Relay also features:
- command line clients
- a GUI configuration tool
- extensive documentation
Enhancements:
- Several contributed patches were applied.
- Oracle stability was improved.
- Support for Oracle OS-authentication was added.
- The maxlisteners option was added.
- Support for Sybase stored procedures which return result sets was added.
- A Zope empty-result set bug was fixed.
- Support for Mac OS X, Solaris, and Cygwin was improved.

EasySQL is a front-end that provides a slightly extended version of the MySQL SQL syntax allowing for far more sophisticated tasks to be accomplished without resorting to using an external language such as Perl.
Main features:
- Iterate across a SQL result set, and execute multiple queries using the values from each result row.
- Connect to multiple data sources and issue individual queries against one or more data sources.

SQL Admin is a Java client application to connect and send queries to different databases through JDBC.
SQLAdmin uses the brand new SWT Toolkit. The main idea is to create a multiplatform and multidatabase thin client. For example, you can connect to an Microsoft SQL Server from a Linux machine, or connect to a PostgreSQL/Linux server from a Windows machine using the same application.
Main features:
- Based on the SWT Tookit. Java applications can use the native Toolkit with a platform independant API. For example, SQLAdmin uses GTK2 in Linux
- Lightweight : The application itself is small, and the SWT provides a nice gui with a very small footprint
- Abstract JDBC driver backend. User should configure only basic parameters like server, port, and login without the need to know about Class names or JDBC URLs
- Graphical view of connections and database metadata such as schemas, tables and fields
- Multiple query execution. Also supports embedded comments on SQL Text
- Log window to view system messages and query results
- Table structure view
- Fast table rows view

SQL::Schema is a Perl module to convert a data dictionary into SQL statements.

SYNOPSIS

use DBI;

my $dbh = DBI->connect(...);

use SQL::Schema;

my $schema = SQL::Schema->new($dbh);

my $sql = $schema->string;
print $sql;

print "$schema";

WARNING

This is alpha software. It currently works with Oracle databases only. The name of the module might be changed in future releases as well as its interface.

If somebody is modifying the datase schema during the life time of an SQL::Schema object, the object will probably fail and / or produce wrong information.

SQL::Schema is a class for objects representing a database schema. The methods of an instanciated object do allow to access the information within a databases data dictionary and to represent them as SQL create statements and the like using the proper SQL dialect.

Constructor

$schema = SQL::Schema->new($dbh);

The new method instanciates a schema object. The only argument required is a database handle, which has to offer the same API as described within DBI(3).

Methods

$sql = $schema->string;

Returns an SQL string containing several statements at once. This string contains all the SQL statements to create the database schema.

This method is overloaded with the string operator. So the following two lines are equivalent:

$sql = $schema->string;
$sql = "$schema";

SQL::Preproc is a Perl module to embed SQL in your Perl (ala SQL preprocessors).

SYNOPSIS

use SQL::Preproc
subclass => Chart,
emit => 1,
keepsql => 1,
syntax => [ Teradata ],
pponly => 1,
relax => 1,
alias => 1,
debug => 1;

use DBI;
use DBI qw(:sql_types);
use SQL::Preproc::ExceptContainer;
use DBIx::Chart;

...some code...

my ($host, $user, $passwd) = @ARGV;

DECLARE CONTEXT $sqlpp_ctxt;

CONNECT TO "Teradata:$host"
USER $userid IDENTIFIED BY $passwd AS myconn WITH tdat_mode => ANSI;

my $more_rows;
WHENEVER NOTFOUND { $more_rows = undef }

WHENEVER SQLERROR {
my ($ctxt, $err, $state, $errmsg) = @_;
die $errmsg;
}

DECLARE CURSOR mycursor AS
SELECT * FROM mytable FOR UPDATE;

OPEN mycursor;

my ($col1, $col2, $col3, $col4);
while ($more_rows) {

FETCH mycursor INTO :$col1, :$col2, :$col3, :$col4;

if ($col1 > $col4) {
UPDATE mytable SET col4 = col4 + 100
WHERE CURRENT OF mycursor;
}
}

CLOSE mycursor;
#
# do a bulkload via array binding
#

my @col1 = ();
my @col2 = ();
my @col3 = ();

#
# load some data into the arrays, then send it to the DBMS
#

EXEC SQL INSERT INTO sometable VALUES(:@col1, :@col2, :@col3);

#
# now create a chart, dumping results to @_
#
SELECT * FROM mytable
RETURNING LINEGRAPH(*), IMAGEMAP
WHERE WIDTH=500
AND HEIGHT=500
AND FORMAT=PNG
AND LOGO=myimage.png
AND X_AXIS=Date
AND Y_AXIS=Stock Price
AND MAPNAME=stockmap
AND SIGNATURE=GOWI Systems, Inc.
AND SHOWPOINTS=1
AND POINT=opencircle;

open(OUTF, >mychart.png) || die $!;
binmode OUTF;
print OUTF, $_[0];
close OUTF;

open(OUTF, >mychart.map) || die $!;
print OUTF, $_[1];
close OUTF;

DISCONNECT myconn;