Free sql queries software for linux

SQLitepp is a C/C++/Python wrapper to sqlite library for database management. It implements an object oriented way to manipulate the database in every supported language.

SQLitepp supports selfupdatable queries and a straight SQL code query system without using strange things for querying the database, letting you manipulate it directly in SQL but also exposing simple object oriented methods to manipulate the result of the queries and updating them.

Python EXAMPLE:

db = SQLDatabase("database.db")
q = db.query("Tablename", "SELECT Name,Id FROM %t")
if len(q):
tuple1 = q[0]
tuple1["Name"] = "Foobar"
tuple1.commit()
del db

C++ EXAMPLE:

SQLDatabase db("database.db");
SQLQuery *q = db.query("Tablename", "SELECT Name,Id FROM %t");
if(q->numberOfTuples()) {
SQLRow *tuple1 = q->getRow(0);
tuple1->set("Name", "Foobar");
tuple1->commit();
}
delete q;

C EXAMPLE:

void *db = new_SQLDatabase("database.db");
void *q = SQLDatabase_query(db, "Tablename", "SELECT Name,Id FROM %t");
if(SQLQuery_numberOfTuples(q)) {
void *tuple1 = SQLQuery_getRow(q, 0);
SQLRow_set(tuple1, "Name", "Foobar");
SQLRow_commit(tuple1);
}
delete_SQLQuery(q);
delete_SQLDatabase(db);

SQL::Amazon::UserGuide is a Perl module with user Guide for DBD/SQL::Amazon.

SYNOPSIS

#
# create the parser, passing in the current Amazon metadata
#
my $parser = SQL::Amazon::Parser->new(%attrs);

#
# parse a SQL statement, returning a SQL::Amazon::Statement
#
my $stmt = $parser->parse($sql_stmt)
or die "Parse failed: " . $parser->errstr;
#
# evaluate the parse tree, using an evaluation object
# for driver specific evaluation
# returns either a scalar rowcount for write operations,
# or a SQL::Amazon::Table object for SELECT
# or undef on error
#
my $results = $stmt->execute($params)
or die "Evaluation failed: " . $stmt->errstr;

SQL::Amazon provides the various components required by DBD::Amazon http://www.presicient.com/dbdamzn to query the Amazon E-Commerce Service 4.0 aka ECS using SQL.

Be advised this is ALPHA release software.

The suite includes the following components:

SQL::Amazon::Parser

provides SQL parsing and query plan generation. Implemented as a subclass of SQL::Parser, part of the SQL::Statement bundle.

SQL::Amazon::Statement

provides SQL query plan execution. Implemented as a subclass of SQL::Statement.

SQL::Amazon::Functions

provides SQL::Amazon-specific predicate functions, including MATCHES ANY, MATCHES ALL, MATCHES TEXT, POWER_SEARCH, IN, and NOT IN.

SQL::Amazon::ReqFactory

provides a factory class for generating SQL::Amazon::Request::Request objects based on the predicates in a querys WHERE clause.

SQL::Amazon::Spool

provides a temporary storage object for intermediate results extracted from the base table cache objects. Acts as a SQL::Eval::Table object for SQL::Statement processing.

SQL::Amazon::StorageEngine

provides a global storage engine for managing data caching and retrieval.

SQL::Amazon::Request::Request

provides a base class for all ECS request objects, including numerous default method implementations for building and sending requests, and processing the responses into the base table cache objects.

SQL::Amazon::Request::ItemLookup

a subclass of SQL::Amazon::Request::Request for the ItemLookup request; also acts as a base class for the ItemSearch request.

SQL::Amazon::Request::ItemSearch

a subclass of SQL::Amazon::Request::ItemLookup for the ItemSearch request

SQL::Amazon::Tables::Table

provides a base class for table cache objects, including methods for data type conversion, keyed lookup, and cache management.

SQL::Amazon::Tables::< tablename >

provides table-specific implementations of the Table base class.

SqlUnify is a library that can convert PostgreSQL queries to other dialects (such as MySQL, FirebirdSQL, MSSQL, and Oracle).
It is useful for supporting different SQL servers in your applications.
Main features:
- SqlUnify can convert PostgreSQL queries to other dialects (MySQL, FirebirdSQL, MSSQL, Oracle...)! No more problems with supporting different SQL servers in your application! The library is available only as binary packages or as a web-based technology preview. SqlUnify is not supporting subqueries and table-definition queries now but it will support it in next versions.

QtSqlView project is a simple and easy to use SQL database browser written in Qt 4.x using the excellent QtSql components. Using QtSql drivers it can natively connect to MySQL, PostgreSQL and SQLite databases. Furthermore other database systems may be accessed using their ODBC drivers. QtSqlView is released under the GNU General Public License: source and win32 binary may be downloaded below.
This short program was initially written for a set of windows users, who need to access and edit a PostgreSQL database. This is possible with M$ Access and ODBC, but the configuration of PostgreSQLs ODBC driver and the ODBC DSN is far too complicated for the average database editor. Thus problem-free access of open-source databases was top priority for QtSqlView.
QtSqlView does not aim to be a generic SQL database tool including table schema editor and dialog-based data entry. For this purpose you may consider using TOra or Kexi.
Main features:
- Problem-free connecting to MySQL, PostgreSQL and SQLite databases on Windows.
- Add, delete and modify a list of database connections.
- Browse, edit, save and revert SQL tables, system tables and views of registered connections
- Copy selected cells as tab-separated text to the clipboard.
- View table schema including primary key.
- Execute custom SQL queries on the database connect and view results.
- SQL syntax highlighting in query editor.
- Uses Qt4s greatly improved SQL components.
The source code package can be built on Linux, Windows, OS/X and probably other Qt platforms using the usual qmake && make commands.
The Windows binary version was built with Qt 4.2 and includes native drivers to access MySQL, PostgreSQL and SQLite databases. No other program package is needed. The versions of the included drivers are available and will be updated when needed.

JDBC SQL Profiler is a quickly hacked tool to do statistics on SELECT queries in order to know where it is most efficient to create indexes.

This small tool, released under an Apache-based license connects to the P6Spy JDBC logger and displays in real time the queries going to the database. It uses an integrated SQL parser to build statistics on the most accessed tables and columns and can generate SQL index creation files.

Other information is also gathered and displayed, such as the request time for a single request, for a class of request, and for all the requests. Sorting may be done on these views to detect database problems efficiently.

This tool can be very useful when you have a big volume of queries that you need to analyze not one by one (meaning that the specific time isnt that much of interest), but rather when you want to know what "group" of queries is taking a lot of time, such as queries on the same tables and columns but with different query values. The integrated SQL parser (built with ANTLR) is used to analyze the incoming SELECT queries.

The Swing GUI was based on Apaches Log4J Chainsaw, but all the bugs are mine. Also contributors are welcome to test, make new suggestions, give their opinion and submit patches.

SafeSQL project is an SQL query processer to automate the tedious tasks of syntax testing, injection attack-proofing, dropping parts of queries and other misc features. It has only been tested with MySQL syntax, but any ANSI SQL-92 compliant db library should work OK.
SYNOPSIS:
require SafeSQL.class.php;
// dummy up a variable with a single quote in it
$section_name = "freds place";
// run the query through SafeSQL
$safesql =& new SafeSQL_MySQL;
$query_string = $safesql->query("select * from sections
where Section_Name = %s", array($section_name));
echo $query_string;
OUTPUT:
select * from sections where Section_Name = freds place
// $query_string is now safe to pass to your SQL library
Enhancements:
- This release adds %n and %N for handling quoted and (non-quoted) NULL values.

iSQL-Viewer is an open-source JDBC 2.x compliant database front end written in Java. It implements across multiple platforms features of the JDBC API. It does everything through a single interface.
iSQL-Viewer works with most database platforms, including PostgreSQL, MySQL, Oracle, and Informix. iSQL-Viewer provides a variety of tools and features to carry out common database tasks.
Main features:
- Scripting support using JPython and the IBM BSF framework
- A guided query builder for creating simple and complex SQL queries
- Enhanced object viewing for images, HTML, and other binary format files
- A friendly SQL console for executing SQL statements
- Batch processing of SQL files
- Database introspection
- "Bookmarks" to store SQL commands you commonly use
- Import and export to popular file formats such as Microsoft Excel, XML, HTML and ASCII delimited.
- Enhanced interface support across platforms
Enhancements:
- A bug caused by closing of the application with a large query left in the editor was fixed along with some issues with variable substitution.
- Some missing elements in the service wizard were corrected.
- MonetDB and Gigaspaces were added as part of the default driver set to pick from when creating a new service.

Querylog project is a console tool for performing SQL queries on a (log) file.

Lines from one or more text files or stdin are matched, using regular expressions to an in memory database on which SQL queries can be performed.

You also specify queries in the config file (SELECTs, INSERTs, CREATE VIEWs, etc). Queries that generate output are printed to stdout in plain text at the moment. In the future it will be possible to specify output formatters. The tool is written in C++ using the boost program options and regex library and the sqlite libraries for the in memory database.

I first wrote this tool to extract accounting information from cups page log files (in which accounting infomation was on different lines than job information), but due to the generic nature of the tool it can be used in many situations in which specific information needs to be retrieved from (in the future multiple) text files and presented in a more usable format.

Building:

Youll need the boost headers and libraries for (program_options and regex) which you can get at http://www.boost.org/, and the sqlite3 headers and libraries which you can get at http://www.sqlite.org/.

Im using boost build, so if you have that all you have to do is run:

> bjam

Alternativly, as the program now has only a single source file, you can just use g++ to compile and link it.

Ill create a nicer build enviroment one of these days.

Running:

Options must be specified on the commandline or in a config file (key = ["]value["]). Run querylog --help for details. The input file may be ommited, in which case data will be read from stdin until the eof.