Free insert statement software for linux

INSERT (the Inside Security Rescue Toolkit) aims to be a multi-functional, multi-purpose disaster recovery and network analysis system. It boots from a credit card-sized CD-ROM and is basically a stripped-down version of Knoppix. It features good hardware detection, fluxbox, emelfm, links-hacked, ssh, tcpdump, nmap, chntpwd, and much more.
INSERT provides full read-write support for NTFS partitions (using captive), and the ClamAV virus scanner (including a fairly recent signature database and a GUI). It also has a network boot facility.
Main features:
- full read-write support for NTFS-partitions using captive
- support for various file system types: EXT2,EXT3,MINIX,REISERFS,JFS,XFS,NTFS,FAT,MSDOS,NFS,SMBFS,NCPFS,UDF,UFS,HFS,HFS+
- support for linux software RAID and LVM
- support for WLAN adapters
- network analysis (e.g. nmap, tcpdump)
- disaster recovery (e.g. parted, gpart, partimage, testdisk, recover)
- virus scanning (Clam Antivirus)
- computer forensics (e.g. chkrootkit, rootkit hunter)
- surf the internet (e.g. links-hacked, AxY FTP)
- network boot server to boot network boot enabled clients that cannot boot from the CD
- based on Linux kernel 2.4.27 and Knoppix 3.6

SQL::Statement::Embed can embed a SQL engine in a DBD or module.

SQL::Statement is designed to be easy to embed in other modules and to be especially easy to embed in DBI drivers. It provides a SQL Engine and the other module needs to then provide a data source and a storage mechanism. For example, the DBD::CSV module uses SQL::Statement as an embedded SQL engine by implementing a file-based data source and by using DBI as the user interface. Similarly DBD::Amazon uses SQL::Statement as its SQL engine, provides its own extensions to the supported SQL syntax, and uses on-the-fly searches of Amazon.com as its data source.

SQL::Statement is the basis for eight existing DBDs (DBI database drivers). If you have a new data source, you too can create a DBD without having to reinvent the SQL wheel. Its fun, its easy, become a DBD author today!

SQL::Statement can be also be embedded without DBI. Well explore that first since developing a DBD uses most of the same methods and techniques.

The role of SQL::Statement subclasses

SQL::Statement provides a SQL parsing and execution engine. It does not provide a data source or storage mechanism other than in-memory tables. The DBD::File module is a subclass of SQL::Statement that provides access to file-based storage mechanisms. Its quite possible to use things other than files as data souces, in which case we wouldnt use DBD::File, instead wed replace DBD::Files methods with our own. In the examples below, well use DBD::File, replacing only a few methods.

SQL::Statement provides SQL parsing and evaluation and DBD::File provides file-based storage. The only thing missing is a data source - what we actually want to store and query. As an example suppose we are going to create a subclass called Foo that will provide as a data source a simple file similar to a passwd file - one record per line, fields separated by colons, with only three fields "username, uid, gid".

Consider what needs to happen to perform a SELECT query on our Foo data:

* recieve a SQL string
* parse the SQL string into a request structure
* open the table(s) specified in the request
* define column names and postions for the table
* read rows from the table
* convert the rows from colon-separated format into perl arrays
* match the columns and rows against the requested selection criteria
* return requested rows and columns to the user

To perform operations like INSERT and DELETE, we also need to:

* convert rows from perl arrays into colon-separated format
* write rows
* delete rows

SQL::Statement takes care of all of the SQL parsing and evaluation. DBD::File takes care of file opening, reading, writing, and deleting. So the only things Foo is really responsible for are:

* define column names and postions for the table
* convert rows from colon-separated format into perl arrays
* convert rows from perl arrays into colon-separated format

In SQL::Statement subclasses these responsibilities are assigned to two objects, a ::Statement object is responsible for opening the table, defining the column names and positions, and for creating new ::Table objects. A ::Table object is responsible for reading, converting, writing, and deleting data.

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
]);

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.

MySQL Abstractor package contains PHP classes that implements a MySQL database abstraction layer.

It provides several classes. There is one for establishing connections and executing SQL queries, another for composing and executing SELECT, INSERT, UPDATE and DELETE queries from a list of parameters, and a wrapper class to simplify the usage of the other two classes.

alterMIME is a small program which is used to alter your mime-encoded mailpacks as typically received by Xamime, Inflex and AMaViS.
Main features:
- Insert disclaimers
- Insert arbitary X-headers
- Modify existing headers
- Remove attachments based on filename or content-type
- Replace attachments based on filename
Enhancements:
- The FFGET engine has been updated.
- Fixed Outlook Calendar kludging has been fixed.
- BASE64 disclaimer insertions have been added.

Set::Scalar Perl module contains a basic set of operations.

SYNOPSIS

use Set::Scalar;
$s = Set::Scalar->new;
$s->insert(a, b);
$s->delete(b);
$t = Set::Scalar->new(x, y, $z);

Creating

$s = Set::Scalar->new;
$s = Set::Scalar->new(@members);

$t = $s->clone;
$t = $s->copy; # clone of clone

Modifying

$s->insert(@members);
$s->delete(@members);
$s->invert(@members); # insert if hasnt, delete if has

$s->clear; # removes all the elements

Note that clear() only releases the memory used by the set to be reused by Perl; it will not reduce the overall memory use.

DBIx::Frame is a Perl module for creating and maintaining DBI frameworks.

SYNOPSIS

use DBIx::Frame;
DBIx::Frame->init(server, dbtype) || exit(0);
my $DB = DBIx::Frame->new(database, user, pass)
or die("Couldnt connect to database: ", DBI->errstr);
See below for how to actually use this object.

DBIx::Frame is an extension of the standard DBI perl module, designed around mysql, and used to create and maintain frameworks for databases. It has query logging, and a standardized interface for standard SQL statements like update and insert that doesnt require understanding SQL to any great degree.

Ideally, the user or developer shouldnt have to know too much SQL to be able to administer a database. On the other hand, it does require a certain setup that isnt necessarily easy to pick up, and isnt standard SQL - with all the problems that this entails.

Database design is discussed below.