Free sql statement software for linux

Regular Statement String (RSS) provides several libraries in C, Java, and COM to implement and demonstrate the key-value development method using well-designed "strings" (RSS) as the media. Regular Statement String also shows a way to write "Process Oriented" applications.
Enhancements:
- This release adds an implementation for SUN Solaris (SPARC).

SQL::Abstract::Limit is a portable LIMIT emulation.

SYNOPSIS

use SQL::Abstract::Limit;

my $sql = SQL::Abstract::Limit->new( limit_dialect => LimitOffset );;

# or autodetect from a DBI $dbh:
my $sql = SQL::Abstract::Limit->new( limit_dialect => $dbh );

# or from a Class::DBI class:
my $sql = SQL::Abstract::Limit->new( limit_dialect => My::CDBI::App );

# or object:
my $obj = My::CDBI::App->retrieve( $id );
my $sql = SQL::Abstract::Limit->new( limit_dialect => $obj );

# generate SQL:
my ( $stmt, @bind ) = $sql->select( $table, @fields, %where, @order, $limit, $offset );

# Then, use these in your DBI statements
my $sth = $dbh->prepare( $stmt );
$sth->execute( @bind );

# Just generate the WHERE clause (only available for some syntaxes)
my ( $stmt, @bind ) = $sql->where( %where, @order, $limit, $offset );

SQL::Interpolate is a Perl module to interpolate Perl variables into SQL statements.

SYNOPSIS

use SQL::Interpolate qw(:all);

# Some sample data to interpolate:
my $s = blue; my @v = (5, 6);

# Variable references are transformed into bind parameters.
# The most basic usage involves scalarrefs (as well as arrayrefs
# preceeded by "IN").
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE x = , $s, AND y IN, @v;
# RESULT:
# $sql = SELECT * FROM mytable WHERE x = ? AND y IN (?, ?)
# @bind = ($s, @v);

# In certain contexts, an arrayref or hashref acts as a single tuple:
my ($sql, @bind) = sql_interp
INSERT INTO table, {x => $s, y => 1};
# RESULT:
# $sql = INSERT INTO mytable (x, y) VALUES(?, ?);
# @bind = ($s, 1);
my ($sql, @bind) = sql_interp
UPDATE table SET, {x => $s, y => 1}, WHERE y , 2;
# RESULT:
# $sql = UPDATE mytable SET x = ?, y = ? WHERE y ?;
# @bind = ($s, 1, 2);

# In general, a hashref provides a shortcut for specifying
# a logical-AND construction:
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE, {x => $s, y => @v};
# RESULT:
# $sql = SELECT * FROM mytable WHERE (x = ? AND y IN (?, ?));
# @bind = ($s, @v);

# In general, an arrayref acts as a result set or reference to
# a temporary table:
my ($sql, @bind) = sql_interp
[[1, 2], [4, 5]], UNION, [{x => 2, y => 3}, {x => 5, y => 6};
# RESULT:
# $sql = (SELECT ?, ? UNION ALL SELECT ?, ?) UNION
# (SELECT ? AS x, ? AS y UNION ALL SELECT ?, ?);
# @bind = (1,2,4,5, 2,3,5,6);
my ($sql, @bind) = sql_interp
SELECT * FROM, [[1, 2], [4, 5]]
# RESULT:
# $sql = SELECT * FROM (SELECT ?, ? UNION ALL SELECT ?, ?) AS tbl0;
# @bind = (1,2,4,5);

# Each result above is suitable for passing to DBI:
my $res = $dbh->selectall_arrayref($sql, undef, @bind);

# Besides these simple techniques shown, SQL-Interpolate includes
# various optional modules to further integrate SQL::Interpolate with
# DBI and streamline the syntax with source filtering and macros (see
# the L section):

use DBIx::Interpolate FILTER => 1;
...
my $rows = $dbx->selectall_arrayref(sql[
SELECT thid, date, title, subject
FROM threads
WHERE date > $x AND subject IN @subjects
]);

SQLAlchemy is a SQL toolkit and object relational mapper for Python.
The Python SQL toolkit and Object Relational Mapper that gives application developers the full power and flexibility of SQL. SQLAlchemy provides a full suite of well known enterprise-level persistence patterns, designed for efficient and high-performing database access, adapted into a simple and Pythonic domain language.
- extremely easy to use for all the basic tasks, such as: accessing thread-safe and pooled connections, constructing SQL from Python expressions, finding object instances, and commiting object modifications back to the database.
- powerful enough for complicated tasks, such as: eager load a graph of objects and their dependencies via joins; map recursive adjacency structures automatically; map objects to not just tables but to any arbitrary join or select statement; combine multiple tables together to load whole sets of otherwise unrelated objects from a single result set; commit entire graphs of object changes in one step.
- built to conform to what DBAs demand, including the ability to swap out generated SQL with hand-optimized statements, full usage of bind parameters for all literal values, fully transactionalized and consistent updates using Unit of Work.
- modular. Different parts of SQLAlchemy can be used independently of the rest, including the connection pool, SQL construction, and ORM. SQLAlchemy is constructed in an open style that allows plenty of customization, with an architecture that supports custom datatypes, custom SQL extensions, and ORM plugins which can augment or extend mapping functionality.
SQLAlchemys Philosophy:
- SQL databases behave less and less like object collections the more size and performance start to matter; object collections behave less and less like tables and rows the more abstraction starts to matter. SQLAlchemy aims to accomodate both of these principles.
- Your classes arent tables, and your objects arent rows. Databases arent just collections of tables; theyre relational algebra engines. You dont have to select from just tables, you can select from joins, subqueries, and unions. Database and domain concepts should be visibly decoupled from the beginning, allowing both sides to develop to their full potential.
- For example, table metadata (objects that describe tables) are declared distinctly from the classes theyre designed to store. That way database relationship concepts dont interfere with your object design concepts, and vice-versa; the transition from table-mapping to selectable-mapping is seamless; a class can be mapped against the database in more than one way. SQLAlchemy provides a powerful mapping layer that can work as automatically or as manually as you choose, determining relationships based on foreign keys or letting you define the join conditions explicitly, to bridge the gap between database and domain.
SQLAlchemys Advantages:
- The Unit Of Work system organizes pending CRUD operations into queues and commits them all in one batch. It then performs a topological "dependency sort" of all items to be committed and deleted and groups redundant statements together. This produces the maxiumum efficiency and transaction safety, and minimizes chances of deadlocks. Modeled after Fowlers "Unit of Work" pattern as well as Java Hibernate.
- Function-based query construction allows boolean expressions, operators, functions, table aliases, selectable subqueries, create/update/insert/delete queries, correlated updates, correlated EXISTS clauses, UNION clauses, inner and outer joins, bind parameters, free mixing of literal text within expressions, as little or as much as desired. Query-compilation is vendor-specific; the same query object can be compiled into any number of resulting SQL strings depending on its compilation algorithm.
- Database mapping and class design are totally separate. Persisted objects have no subclassing requirement (other than object) and are POPOs : plain old Python objects. They retain serializability (pickling) for usage in various caching systems and session objects. SQLAlchemy "decorates" classes with non-intrusive property accessors to automatically log object creates and modifications with the UnitOfWork engine, to lazyload related data, as well as to track attribute change histories.
- Custom list classes can be used with eagerly or lazily loaded child object lists, allowing rich relationships to be created on the fly as SQLAlchemy appends child objects to an object attribute.
- Composite (multiple-column) primary keys are supported, as are "association" objects that represent the middle of a "many-to-many" relationship.
- Self-referential tables and mappers are supported. Adjacency list structures can be created, saved, and deleted with proper cascading, with no extra programming.
- Data mapping can be used in a row-based manner. Any bizarre hyper-optimized query that you or your DBA can cook up, you can run in SQLAlchemy, and as long as it returns the expected columns within a rowset, you can get your objects from it. For a rowset that contains more than one kind of object per row, multiple mappers can be chained together to return multiple object instance lists from a single database round trip.
- The type system allows pre- and post- processing of data, both at the bind parameter and the result set level. User-defined types can be freely mixed with built-in types. Generic types as well as SQL-specific types are available.

SQLyog is an easy to use tool that lets you manage your MySQL database anywhere in the world. SQLyog is a tool that allows you manage MySQL database.
Main features:
Developer / User Productivity
- HTML Schema Documentation
- Shortcuts to quickly generate SQL statements and paste object names
- Learn MySQL by looking at the SQL generated by SQLyog
- Multi-tab Query Editor and Result-set Editor
- Multiple Query Execution
- Multi-threaded Query execution with option to stop long running queries
- SQL Templates
- Excel-style grid interface to view/update resultsets
- Multi-format Blob editor
- View data in Grid/Text Mode
- ResultSet/Data Export to CSV/XML/HTML
- Full Support from 3.23.38 to the latest 5.x
- Support for all MySQL table handlers
- Excel friendly resultsets/table-data export to clipboard/file
- Dialogless table and resultset editor
DBA Productivity
- Restoring / Importing large SQL dumps
- MySQL 5.x objects support
- User Management
- Managing hosted MySQL
- Connection Manager
- Index Management
- Relationship/Foreign Key Manager
- Reorder Columns
- Copy objects to another Host with single click
- Table diagnostics
- Flush Tools
- Object Browser
- Creating/dropping database
- Optimized for managing Hosted MySQL
- Profiling
- Multiple database connections
Technology
- Turbo Speed MySQL Management. Uses native MySQL C API - the fastest way to communicate with MySQL server
- 100% keyboard friendly
- Small compact binary
- Minimal use of Registry - easy migration of User Preferences by dragging and dropping config files.
- Non-cluttered look and feel, ability to show/hide panes

SQuirreL SQL Client is a graphical Java program that will allow you to view the structure of a JDBC compliant database, browse the data in tables, issue SQL commands etc. The minimum version of Java supported is 1.4.x. We recommend 1.5.x. See the Old Versions page for versions of SQuirreL that will work with older versions of Java.

SQuirreLs functionality can be extended through the use of plugins. A short introduction can be found here. To see the change history (including changes not yet released) click here.

Susan Cline graciously took the time to document the steps she followed to setup an Apache Derby database from scratch and use the SQuirreL SQL Client to explore it.
Quite some time ago Kulvir Singh Bhogal wrote a great tutorial on SQuirreL and published it at the IBM developerWorks site. He has kindly allowed us to mirror it locally. The tutorial is not really up to date but especially for doing the first steps it is still of help.

SQuirrel was originally released under the GNU General Public License. Since version 1.1beta2 it has been released under the GNU Lesser General Public License.

Whats New in This Release:

1716859 Cant see data in content tab or row count tab (MS SQLServer databases
with a dash ("-") in their name would cause the content tab or row count
tabs to render no data.

1714476: (DB copy uses wrong case for table names) The copy operation would
sometimes fail to select records from the source table. Since the
case for the source table is always known to be correct, the plugin
no longer erroneously attempts to correct the case.

1700093: Formatter fails for insert script with multiple subselects

Refactoring Plugin: SQL-Server needs eol between GO and statement.

Fixed bug which appeared while editing tables in PostgreSQL 8.1. If the table
was created without an OID column, the last column would not be editable.

Fix for issue where dates arent correctly displayed or updated when using
treat date as timestamp pref in the SQl Editor result panel.

Use the last directory that a file was imported from when importing additional
files for binary fields.

1699294: Squirrel imports BLOB, but does not update data

Oracle Plugin: Handle slashes when they are used as statement separators.

137984 (Bug in alias delete) The problem was that notifications were being
sent to the alias drop-down that the item was being deleted which trigger an
update and new selection forcing the connect to alias window to be launched.
Now, the alias drop down is disabled while the update is happening and enabled
immediately afterward.

TbsSQL is a PHP class for SQL abstraction. TbsSQLs goal of this tool is to reduce the code when working with SQL through PHP. The TbsSQL is available for the following databases:
- MySQL
- MySQLi
- SQL-Server (via Ms-Odbc)
- PostgreSQL (version 7.2 or higher)
Example:
$id = 29;
$name = "boby";
$Db->Execute(UPDATE table1 SET name=@2@ WHERE (id=%1%), $id, $name);
In this example, the SQL statement sent to the database will be: UPDATE table1 SET name=boby WHERE (id=29)
TbsSQL supports the following jokers in your SQL statements (n must be the number of the place of the argument in the TbsSQL command)
- %n% the argument will be protected against Sql Injection.
- @n@ the argument will be protected against Sql Injection and delimited as a string value with the relevant format for the database.
- #n# the argument will be converted as a date value without time with the relevant format for the database.
- ~n~ the argument will be converted as a date and time value with the relevant format for the database.
Enhancements:
- This release can retrieve a list of keys/values.
- It can delete PHP connection variables after making the connection.
- MySQLi is now supported.