Free sqlite3 software for linux

php-sqlite3 project is a PHP extension that lets you access SQLite3 databases within your scripts.
PHP 4 and PHP 5 have already built-in support for this RDBM, but this is limited to the 2.x releases. This extension adds support for SQLite 3.x release.
Please note that this project is still alpha-quality. Please test and report if it works for you and how it can be enhanced.
Current (or planned) features include:
In-memory databases support
UTF-16 encoding
User-level SQL functions
PEAR::DB driver class
Enhancements:
- fix BEGIN...END/ROLLBACK statments queries (thanks to John Morrissey!)
- better support for BLOB columns (thanks to Michal Srajer!)

SQLite is a small C library that implements a self-contained, embeddable, zero-configuration SQL database engine.
Main features:
- Transactions are atomic, consistent, isolated, and durable (ACID) even after system crashes and power failures.
- Zero-configuration - no setup or administration needed.
- Implements most of SQL92. (Features not supported)
- A complete database is stored in a single disk file.
- Database files can be freely shared between machines with different byte orders.
- Supports databases up to 2 terabytes (241 bytes) in size.
- Sizes of strings and BLOBs limited only by available memory.
- Small code footprint: less than 30K lines of C code, less than 250KB code space (gcc on 486)
- Faster than popular client/server database engines for most common operations.
- Simple, easy to use API.
- TCL bindings included. Bindings for many other languages available separately.
- Well-commented source code with over 95% test coverage.
- Self-contained: no external dependencies.
- Sources are in the public domain. Use for any purpose.
The SQLite distribution comes with a standalone command-line access program (sqlite) that can be used to administer an SQLite database and which serves as an example of how to use the SQLite library.
Create A New Database:
- At a shell or DOS prompt, enter: "sqlite3 test.db". This will create a new database named "test.db". (You can use a different name if you like.)
- Enter SQL commands at the prompt to create and populate the new database.
Write Programs That Use SQLite
Below is a simple TCL program that demonstrates how to use the TCL interface to SQLite. The program executes the SQL statements given as the second argument on the database defined by the first argument. The commands to watch for are the sqlite3 command on line 7 which opens an SQLite database and creates a new TCL command named "db" to access that database, the invocation of the db command on line 8 to execute SQL commands against the database, and the closing of the database connection on the last line of the script.
#!/usr/bin/tclsh
if {$argc!=2} {
puts stderr "Usage: %s DATABASE SQL-STATEMENT"
exit 1
}
load /usr/lib/tclsqlite3.so Sqlite3
sqlite3 db [lindex $argv 0]
db eval [lindex $argv 1] x {
foreach v $x(*) {
puts "$v = $x($v)"
}
puts ""
}
db close

sqlitewrapped is a C++ wrapper for the Sqlite database C application programming interface.
The code works for linux/unix, as well as win32. This library supports version 3 of the sqlite database. From version 1.2 the connection pool can be made threadsafe.
Examples:
#include < stdio.h>
#include < stdlib.h>
#include < sqlite3.h>
#include < string>
#include "Database.h"
#include "Query.h"
int main()
{
Database db( "database_file.db" );
Query q(db);
q.execute("delete from user");
q.execute("insert into user values(1,First Person)");
q.execute("insert into user values(2,Another Person)");
q.get_result("select num,name from user");
while (q.fetch_row())
{
long num = q.getval();
std::string name = q.getstr();
printf("User#%ld: %sn", num, name.c_str() );
}
q.free_result();
}
Enhancements:
- This release adds methods to access values in the result set by column name.

LiteSQL is a C++ library that integrates C++ objects tightly to relational database and thus provides an object persistence layer.
LiteSQL supports SQLite3, PostgreSQL and MySQL as backends. LiteSQL creates tables, indexes and sequences to database and upgrades schema when needed.
LiteSQL provides object relations, in addition to object persistence which can be used to model any kind of C++ data structures. Objects can be selected, filtered and ordered using template- and class-based API with type checking at compile time.
Main features:
- SQLite3, PostgreSQL and MySQL - backend support
- object persistence layer with relation support
- automatic database schema creation and upgrading
- create complex SQL queries using compile time checked class API; minimizes need to write SQL query strings

LiteMan is a simple GUI database manager for the SQLite embeded database engine version 3. It is written in C++ using the Qt toolkit, and is free software under the terms of the GNU GPL license.
LiteMan is meant to be used a quick tool to build database files for dynamic websites and application file formats, but can be used as a generic database application (though a low-level one).
Main features:
- Create and view any SQLite3 database file
- Create, delete and alter new and existing tables
- Create and delete database views
- Run quaries by either direct SQL code or by a dialog
- Export your tables and views to a SQL dump file
Known Issues (and missing features)
- Table field comments are not stored.
- The only way to alter a table is to rename it. Anything other requires re-creating the table.
- There are no means to alter a view.

Lightbird project is a try to create simple IM service for a LAN. It starts like a ICQ Groupware clone.

It uses mono and theoretically runs in all platforms (Gnu,Macosx and Windows). In Windows you can use .NET framework and install GTK Sharp.

Lightbird server uses Sqlite3 as users and messages DB.

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.