Free sqlite examples software for linux

GNUstep examples is a collection of programs that are meant to show programmers how to use GNUstep.
GNUstep examples includes a calculator, a currency converter, finger, fractal, puzzle, hostaddress, and ink (a simple editor).
Enhancements:
- Minor feature enhancements

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.

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

VSQLite++ is a portable SQLite wrapper library for C++.
Supported Compilers
- GCC and G++ 4.x (maybe 3.4.x too, but it wasnt tested until now)
- Visual C++ 8/2005 (Visual C++ 7.1/2003 wasnt tested, maybe will be added later)

phpSQLiteAdm is an application to provide Web based management and administration for SQLite databases.
phpSQLiteAdm project is meant to be similar to phpMyAdmin. It provides functionality to view data, to add and drop tables, views, and indexes, to export data, to add and delete rows, and to query the database.
Enhancements:
- This is the initial release.
- Code cleanup and bugfixes were done.

pysqlite is a Python DB-API 2.0 interface for the SQLite embedded relational database engine.
Enhancements:
- pysqlite is now 2.5 times faster for DML statements.
- This pays off especially for bulk-loading data.
- pysqlite now recognizes if the database engine has done an implicit ROLLBACK and acts accordingly.
- Using custom mapping and sequence types in parameters works now.

[COPRIGHT=1]

EXAMPLES

General

#!/usr/bin/perl -w
use strict;
use DBIx::Simple;

# Instant database with DBD::SQLite
my $db = DBIx::Simple->connect(dbi:SQLite:dbname=file.dat)
or die DBIx::Simple->error;

# Connecting to a MySQL database
my $db = DBIx::Simple->connect(
DBI:mysql:database=test, # DBI source specification
test, test, # Username and password
{ RaiseError => 1 } # Additional options
);

# Using an existing database handle
my $db = DBIx::Simple->connect($dbh);

# Abstracted example: $db->query($query, @variables)->what_you_want;

$db->commit or die $db->error;

Simple Queries

$db->query(DELETE FROM foo WHERE id = ?, $id) or die $db->error;

for (1..100) {
$db->query(
INSERT INTO randomvalues VALUES (?, ?),
int rand(10),
int rand(10)
) or die $db->error;
}

$db->query(
INSERT INTO sometable VALUES (??),
$first, $second, $third, $fourth, $fifth, $sixth
);
# (??) is expanded to (?, ?, ?, ?, ?, ?) automatically

Single row queries

my ($two) = $db->query(SELECT 1 + 1)->list;
my ($three, $four) = $db->query(SELECT 3, 2 + 2)->list;

my ($name, $email) = $db->query(
SELECT name, email FROM people WHERE email = ? LIMIT 1,
$mail
)->list;

Or, more efficiently:

$db->query(SELECT 1 + 1)->into(my $two);
$db->query(SELECT 3, 2 + 2)->into(my ($three, $four));

$db->query(
SELECT name, email FROM people WHERE email = ? LIMIT 1,
$mail
)->into(my ($name, $email));

GCJ::Cni::Examples is a Perl module with examples of how to use GCJs CNI interface to write Perl Modules in Java.

EXAMPLES

Writing Treaded modules in Java

One benefit of using GCJ is that it takes advantage of POSIX threading. This is nice since Perls threading model is, shall we say, less than ideal. Now, you could theoretically write a module in C or C++ and and use the standard POSIX library to do your threaded work for you, however, why not take advantage of the nice Threading interface that Java provides to you by default. This may also come in handy if you have a massively threaded Java library that youd like to call from Perl.

For this example assume that I want to do matrix multiplication, albeit in a very crazy manner. Therefore, I will write a Java class, Matrix, and a method, multiply, which will take another matrix to perform the operation between. Heres the crazy part, for each cell in the resulting matrix I will spawn a new thread, as an internal class, and give it a row and a column from which they will derive the result. I know this is a little wierd but the point is that Ill be spawning a lot of new threads. To multiply two 10x10 matrices we will have to spawn 100 threads (one thread per cell in the resulting 10x10 matrix). Imagine doing this in Perl, then imagine doing it in Java; natively compiled Java. Much faster and a lot less headaches.

The Java Interface/pseudocode is as follows:

public class Matrix {
public Matrix ( int numRows, int numCols ) {
...Constructor stuff...
}

public void set ( int row, int col, int val ) {
...set an element...
}

public int get ( int row, int col ) {
...get an element...
}

public Matrix multiply ( Matrix times ) {
...set it up...
for ( int i = 0; i < rows; i++ ) {
for ( int j = 0; j < times.getCols(); j++ ) {
//GO NUTS!!!!
ArrayMultiplier multiplier = new ArrayMultiplier(this, times, result, i, j);
multiplier.start();
...etc...
}
}
...wait for the threads to exit and return the new matrix...
}

public int getRows ( ) {
...get number of rows...
}

public int getCols ( ) {
...get number of columns...
}

public void print ( ) {
...print the matrix to stdout...
}

private class ArrayMultiplier extends Thread {
public ArrayMultiplier ( Matrix a, Matrix b, Matrix result, int row, int col ) {
...Construct this bad boy...
}

public void run ( ) {
int sum = 0;
for ( int i = 0; i < a.getCols(); i++ ) {
sum += (a.get(row, i) * b.get(i, col));
}
result.set(row, col, sum);
}

}
}
Now, we want to call this class from Perl. My perferred manner is through SWIG so thats what were going to use. However, you do not need to use SWIG, you can use whatever method you prefer when wrapping C++ classes. We begin by creating a C++ header file from our above class. This is done by using GCJs gcjh utility. First we need to class compile Matrix.java

gcj -C Matrix.java

Then we go ahead and create the header file:

gcjh Matrix

Easy enough. We can then extract the interface we want to have available in Perl from the generated header file and from it create a i file to be used as input to SWIG. I usually start by copying my header file to the same named file but with an i extension instead. I then remove all of the grimy C++ gruff, private methods and variables, slap a module directive on it and call it done. It wont always be this easy though. When youre done an interface file for the above class should look something like this:

%module Matrix;

typedef int jint;

class Matrix
{
public:
Matrix (jint, jint);
virtual void set (jint, jint, jint);
virtual jint get (jint, jint);
virtual ::Matrix *multiply (::Matrix *);
virtual jint getRows ();
virtual jint getCols ();
virtual void print ();
};
We then put SWIG to work and generate our C++ wrapper for Perl:

swig -perl -c++ Matrix.i

After the above command we now will see two new files in our current directory, Matrix.pm and Matrix_wrap.cxx; these correspond the module directive we gave in Matrix.i.

At this point all we have left to do is compile, and use.

gcj -c Matrix.java
gcc -c -I -include Matrix.h Matrix_wrap.cxx
gcc -shared -lgcj -lstdc++ Matrix.o Matrix_wrap.o -oMatrix.so

A simple Perl file using this module might look something like:

sub populate_matrix {
my $matrix = shift;
for ( my $i = 0; $i < $matrix->getRows(); $i++ ) {
for ( my $j = 0; $j < $matrix->getCols(); $j++ ) {
$matrix->set($i, $j, $i * $j);
}
}
}

use GCJ::Cni;
use Matrix;

GCJ::Cni::JvCreateJavaVM(undef);
GCJ::Cni::JvAttachCurrentThread(undef, undef);

my $matrix = new Matrix::Matrix(10, 10);
populate_matrix($matrix);
my $matrix2 = new Matrix::Matrix(10, 10);
populate_matrix($matrix2);
$matrix3 = $matrix->multiply($matrix2);
$matrix3->print();

GCJ::Cni::JvDetachCurrentThread();

Ill leave it up to the reader to write a Perl module that does the same thing, that is, spawns 100 threads. In my own personal fiddling I found that just spawning that many threads (never mind doing any kind of work) was over 3 time slower in Perl. In this situation we at least get to use our favorite language, Perl, and offload some of the heavy hitting to a language more suited for it.

Where this really comes in handy is when you have an existing multi-threaded Java library that you would like to expose to Perl. You could theoretically natively compile various components of your library and then generate Perl bindings to access it. In this way, you get a little extra speed and efficiency as well as code reuse and binding.