Free varchar software for linux

wapircgw helps you easily connect to irc networks using your wap browser on your mobile phone. You just need a Linux box with internet connection to act as a gateway between your mobile phone and the irc network. You can join to multiple channels and talk to others privately like when you use a real irc client.
wapircgw consists of 2 cooperative pieces: wapircphp and wapircd.
wapircd is the daemon which handles connections to irc networks and requests from your mobile phone. wapircphp generates wml webpages that you can view with your mobile phone. So youll need a web-server application with PHP and MySQL support (ex. Apache). MySQL support is needed because of the user administration and settings storage.
Example: when a user logs in with his/her mobile phone, wapircphp communicates with wapircd, requesting a new irc connection to be made. So wapircd connects to the given irc server and joins the channels which the user gave in his/her settings. When the user logs out (or does nothing for a few minutes), wapircd closes the connection with the irc server.
Installation:
Dont forget to edit wapircd password in wapircd/src/config.h!
Then run ./configure and then make. PLEASE REMEMBER: you dont have to be root to run wapircd. Its more secure to run it as a single user. Youll find the wapircd binary in the src dir after running make, but if youre lazy you can run make install as root and itll place the binary in /usr/local/bin. Run wapircd -h for further options. You dont have to have write access in the directory you start wapircd, because everything is stored in memory.
After starting wapircd, copy the contents of the wapircphp directory to your website. Add the following table to your MySQL database:
CREATE TABLE `wapirc` (
`user` varchar(20) default NULL,
`pass` varchar(20) default NULL,
`ircserver` varchar(50) default NULL,
`ircport` varchar(5) default 6667,
`ircuser` varchar(50) NOT NULL default wapirc,
`ircnick` varchar(50) default NULL,
`ircpass` varchar(20) default NULL,
`autojoin` varchar(255) default NULL,
`loglines` tinyint(3) unsigned NOT NULL default 20,
`loglineslong` tinyint(3) unsigned NOT NULL default 100,
`allowrawirccmds` tinyint(1) NOT NULL default 0
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
Enhancements:
- Host resolving did not work under Solaris; this has been fixed.

JDBC is a Perl 5 interface to Java JDBC (via Inline::Java).

SYNOPSIS

use JDBC;

JDBC->load_driver("org.apache.derby.jdbc.EmbeddedDriver");

my $con = JDBC->getConnection($url, "test", "test");

my $s = $con->createStatement();

$s->executeUpdate("create table foo (foo int, bar varchar(200), primary key (foo))");
$s->executeUpdate("insert into foo (foo, bar) values (42,notthis)");
$s->executeUpdate("insert into foo (foo, bar) values (43,notthat)");

my $rs = $s->executeQuery("select foo, bar from foo");
while ($rs->next) {
my $foo = $rs->getInt(1);
my $bar = $rs->getString(2);
print "row: foo=$foo, bar=$barn";
}

This JDBC module provides an interface to the Java java.sql.* and javax.sql.* JDBC APIs.

Persistent::Oracle is a persistent class implemented using an Oracle database.

SYNOPSIS

use Persistent::Oracle;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::Oracle(dbi:Oracle:ORCL,
scott, tiger, emp);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses an Oracle database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Persistent::mSQL is a persistent class implemented using a mSQL database.

SYNOPSIS

use Persistent::mSQL;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::mSQL($data_source, undef, undef, $table);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a mSQL database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

Skeleton Engine for MySQL is a full framework to plug in a new storage engine. Comes with prebuild autoconf files, and a full framework to plug in your own design.

The AWS, HTTP, Memcache, Nitro, PBXT, and many other engines were put together from the skeleton engine.

To install, grab a copy of the mysql source code and run this:
./configure --with-mysql=/home/brian/mysql-5.1/ --libdir=/usr/local/lib/mysql/
make install

And then inside of MySQL:

mysql> INSTALL PLUGIN skeleton SONAME libskeleton_engine.so;

mysql> CREATE TABLE `d` (`a` varchar(125), b text, primary key(a)) ENGINE=skeleton DEFAULT
CHARSET=latin1;
Query OK, 0 rows affected (0.01 sec)

You will probably need to edit the Makefile.am in the src/ tree if you want to build on anything other then Linux (and the Makefile assumes that the server was not compiled for debug).

Data::Type is a Perl module with versatile data and value types.

SYNOPSIS

use Data::Type qw(:all);
use Error qw(:try);

try
{
verify $email , EMAIL;
verify $homepage , URI(http);
verify $cc , CREDITCARD( MASTERCARD, VISA );
verify $answer_a , YESNO;
verify $gender , GENDER;
verify one , ENUM( qw(one two three) );
verify [qw(two six)], SET( qw(one two three four five six) ) );
verify $server_ip4 , IP(v4);
verify $server_ip6 , IP(v6);

verify A35231AH1 , CINS;
verify 14565935 , ISSN;
verify DE , LANGCODE;
verify German , LANGNAME;

verify 012345678905, UPC();
verify 5276440065421319, CREDITCARD( MASTERCARD ) );

verify ATGCAAAT , BIO::DNA;
verify AUGGGAAAU , BIO::RNA;

verify 01001001110110101, BINARY;
verify 0F 0C 0A, HEX;

verify 0 , DEFINED;
verify 234 , NUM( 20 );
verify 1 , BOOL( true );
verify 100 , INT;
verify 1.1 , REAL;

my $foo = bless( 123, SomeThing );

verify $foo , REF;
verify $foo , REF( qw(SomeThing Else) );
verify [ bar ] , REF( ARRAY );

verify x 20 , VARCHAR( 20 );
verify 2001-01-01 , DATE( MYSQL );
verify 16 Nov 94 22:28:20 PST , DATE( DATEPARSE );
verify 9999-12-31 23:59:59, DATETIME;
verify 1970-01-01 00:00:00, TIMESTAMP;
verify -838:59:59 , TIME;
verify 2155 , YEAR;
verify 69 , YEAR(2);
verify 0 x 20 , TINYTEXT;
verify 0 x 20 , MEDIUMTEXT;
verify 0 x 20 , LONGTEXT;
verify 0 x 20 , TEXT;

verify 80 , PORT;
verify www.cpan.org, DOMAIN;
}
catch Type::Exception with
{
my $e = shift;

printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;

foreach my $entry ( testplan( $e->type ) )
{
printf "texpecting it %s %s ", $entry->[1] ? is : is NOT, $entry->[0]->info();
}
};

# believe it or not, this really works

foreach ( EMAIL, WORD, CREDITCARD( MASTERCARD, VISA ), BIO::DNA, HEX )
{
print $_->info;
print $_->usage;
print $_->export; # does it have other names
print $_->param; # what are my choice i.e. [yes,no]
print $_->isa( IType::Business ); # is it a Business related type ?
print $_->VERSION; # first apperance in Data::Type release
}

# tied interface (alias typ)

try
{
typ ENUM( qw(DNA RNA) ), ( my $a, my $b );

print "a is typed" if istyp( $a );

$a = DNA; # $alias only accepts DNA or RNA
$a = RNA;
$a = xNA; # throws exception

untyp( $alias );
}
catch Type::Exception ::with
{
printf "Expected %s %s at %s line %sn",
$e->value,
$e->type->info,
$e->was_file,
$e->was_line;
};

dverify( $email, EMAIL ) or die $!;

my $g = Data::Type::Guard->new(

allow => [ Human, Others ], # blessed objects of that type

tests =>
{
email => EMAIL( 1 ), # mxcheck ON ! see Email::Valid
firstname => WORD,
social_id => [ NUM, VARCHAR( 10 ) ],
contacts => sub { my %args = @_; exists $args{lucy} },
}
);

$g->inspect( $h );

# compact version

overify { email => EMAIL( 1 ), firstname => WORD }, $object_a, $object_b;

print toc();

print catalog();

This module supports versatile data and value types. Out of the ordinary it supports parameterised types (like databases have i.e. VARCHAR(80) ). When you try to feed a typed variable against some odd data, this module explains what he would have expected.

PHP Sessions Management Class is a php class to handle sessions by using a mySQL database for session related data storage providing better security then the default session handler used by PHP.
If you are not familiar with what php sessions are and what are they good for, check out the dedicated chapter in the php manual
If you are familiar with php sessions and you want to use this php class in your projects then remember that to prevent session hijacking, you must not forget to use the regenerate_id() method whenever you do a privilege change in your application
Before usage, make sure you use the session_data.sql file (which is a sql dump file generated with phpMyAdmin) from the install_sql folder to set up the table used by the class
You dont need to modify anything in your previous applications: after instantiating the php class, just use sessions as you would normally.
Note:
The class assumes that there is an active connection to a mySQL database and it does not attempt to create one. This is due to the fact that, usually, there is a config file that holds the database connection related information and another class, or function that handles database connection. If this is not how you do it, you can easily adapt the code by putting the database connection related code in the "open" method of the class.
Enhancements:
- The get_users_online() method is now more accurate as it now runs the garbage collector before getting the number of online users.
- The structure of the MySQL table used by the class was tweaked in so that the "http_user_agent" field was changed from VARCHAR(255) to TEXT to accomodate user agent strings that are longer than 255 characters.
- The "session_data" field was also changed from TEXT to BLOB to help users who store a large amount of data in sessions.