Free sql varchar software for linux

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.

MySQL table patcher is a patch that reads table creation file (tables.sql) and compares it to what mysqldump gives. It creates SQL clauses to update the database to match the creation file.

SQL::Generator is a Perl module to generate SQL-statements with oo-perl.

SYNOPSIS

use SQL::Generator;

With this module you can easily (and very flexible) generate/construct sql-statements. As a rookie, you are used to write a lot of sprintf`s every time i needed a statement (i.e.for DBI).

Later you start writing your own functions for every statement and every sql-dialect (RDBMS use to have their own dialect extending the general SQL standard). This SQL::Generator module is an approach to have a flexible abstraction above the statement generation, which makes it easy to implement in your perl code. Its main purpose is to directly use perl variables/objects with SQL-like code.

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.

mysqlrowcopy is a tool that generates insert statements from result sets. It produces output similar to what might result from running mysqldump on a single SELECT query.

This project helps eliminate some of the tedium of moving data between QA and production MySQL databases.

Build:

To build mysqlrowcopy, you should run:

./configure
make

A mysqlrowcopy and mysqlrowcopy.debug file are created. They have identical functionality, the .debug version simply has debugging symbols built in (for gdb).

Since mysqlrowcopy is probably going to be I/O bound with modest CPU and RAM usage, the only reason to even build a 64-bit version is to work around potential issues in dynamic linking 32-bit binaries against 64-bit libraries.

RECIPES

1. Migrating a MySQL user account reaper from QA server to a production server.

e.g. MySQL database server qa3.example.com to prod1.example.com:

$ mysqlrowcopy -h qa3.example.com
SELECT * FROM db WHERE User = "reaper" mysql db > reaper.sql
$ mysql -h prod1.example.com mysql < reaper.sql

You could of course simply pipe the output of mysqlrowcopy into mysql and skip the intermediate file.

(Dont forget to RELOAD PRIVILEGES afterwards)

2. Keep your test environment up to date. Populate it with production data every 24 hours. You could run this sequence from cron once a day:

$ mysqlrowcopy -h finance-db.example.com
SELECT * FROM stocks WHERE modified > DATE_SUB(NOW(),INTERVAL 24 HOUR)
finance stocks > day-stocks.sql

$ cat day-stocks.sql | mysql -h finance-test.example.com finance

3. Copy data between tables on different servers that have some similar fields.

Youve got common data in table Zip on a production database:

mysql> desc Zip;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ZIPCode | varchar(5) | | PRI | | |
| ZIPCodeType | char(1) | YES | | NULL | |
| City | varchar(32) | YES | | NULL | |
| CityType | char(1) | YES | | NULL | |
| State | varchar(32) | YES | | NULL | |
| StateCode | char(3) | YES | | NULL | |
| AreaCode | char(3) | YES | | NULL | |
| Latitude | varchar(12) | YES | | NULL | |
| Longitude | varchar(12) | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
9 rows in set (0.00 sec)

And youve got table ZipPosition in a research database:

mysql> desc ZipPosition;
+-------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ZIPCode | varchar(5) | | | | |
| Latitude | varchar(12) | YES | | NULL | |
| Longitude | varchar(12) | YES | | NULL | |
+-------------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

You want to load data from production Zip into research ZipPosition.

$ mysqlrowcopy -h production SELECT ZIPCode,Latitude,Longitude common ZipPosition > pos.sql
$ cat pos.sql | mysql -h qa research

Note how we specify ZipPosition on the first line to tell mysqlrowcopy what the destination table is going to be.

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.

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;

DBIx::SQL::Abstract is a Perl module that provides a convenient abstraction layer to a database.

SYNOPSIS

use DBIx::SQL::Abstract;

my $dbh = DBIx::SQL::Abstract->new( %dbcfg );

Building SQL Abstractions.

my($query, @bind) = $dbh->select($table, @fields, %where, @order);
my($query, @bind) = $dbh->insert($table, %fieldvals || @values);
my($query, @bind) = $dbh->update($table, %fieldvals, %where);
my($query, @bind) = $dbh->delete($table, %where);

Using DBI methods

my $sth = $dbh->prepare($query);
$sth->execute(@bind_params);
...
my $rc = $dbh->begin_work;
my $rc = $dbh->commit;
my $rc = $dbh->rollback;
my $rc = $dbh->disconnect;

Anything else DBI method can be used, by Example:

my $err = $dbh->err;
my $err = $dbh->errstr;
my $rv = $dbh->state;
my $rc = $dbh->DESTROY;

The intention of this module is to join some methods from the DBI and the SQL::Abstract modules, for a convenient and easy use.

To begin, we create an object, but first we must create a hash which contains the database parameters as follows.

my %dbcfg = { PrintError => 1,
RaiseError => 0,
AutoCommit => 0,
ChopBlanks => 1
driver => Pg,
dbname => db,
host => undef,
port => undef,
user => user,
passwd => undef
};

Notice that this parameters are set as default unless you set your required values.
my $dbh = DBIx::SQL::Abstract->new( %dbcfg );

This object automatically creates the connection with the database, and gets the methods listed above.