scip/note
1
0
Fork 0
mirror of https://codeberg.org/scip/note.git synced 2025-12-17 20:51:02 +01:00
Code Issues Packages Projects Releases Wiki Activity

-

Browse Source
This commit is contained in:
TLINDEN
2012-02-10 20:24:51 +01:00
parent 9cf564ffe4
commit f548a0a1e2
70 changed files with 973 additions and 9136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
NOTEDB/CVS/Entries
View File

@@ -1,5 +1,5 @@
/README/1.1.1.1/Sat Jul 1 14:40:52 2000//
/binary.pm/1.1.1.1/Sat Jul 1 14:40:52 2000//
/dbm.pm/1.1.1.1/Sat Jul 1 14:40:52 2000//
/mysql.pm/1.1.1.1/Sat Jul 1 14:40:52 2000//
/binary.pm/1.3/Fri Aug 11 00:05:58 2000//
/dbm.pm/1.3/Fri Aug 11 00:05:58 2000//
/mysql.pm/1.3/Fri Aug 11 00:05:58 2000//
D

417
NOTEDB/binary.pm
View File

@@ -1,5 +1,5 @@
#!/usr/bin/perl
# $Id: binary.pm,v 1.1.1.1 2000/07/01 14:40:52 zarahg Exp $
# $Id: binary.pm,v 1.3 2000/08/11 00:05:58 zarahg Exp $
# Perl module for note
# binary database backend. see docu: perldoc NOTEDB::binary
#
@@ -14,185 +14,179 @@ use NOTEDB;
use Fcntl qw(LOCK_EX LOCK_UN);
# Globals:
my ($NOTEDB, $sizeof, $typedef,$version);
my ($cipher);
$version = "(NOTEDB::binary, 1.6)";
sub new
{
my($this, $dbdriver, $dbname, $MAX_NOTE, $MAX_TIME) = @_;
my($this, $dbdriver, $dbname, $MAX_NOTE, $MAX_TIME) = @_;
my $class = ref($this) || $this;
my $self = {};
bless($self,$class);
$NOTEDB = $dbname;
my $class = ref($this) || $this;
my $self = {};
bless($self,$class);
if(! -e $NOTEDB)
{
open(TT,">$NOTEDB") or die "Could not create $NOTEDB: $!\n";
close (TT);
}
elsif(! -w $NOTEDB)
{
print "$NOTEDB is not writable!\n";
exit(1);
}
if(! -e $dbname) {
open(TT,">$dbname") or die "Could not create $dbname: $!\n";
close (TT);
}
elsif(! -w $dbname) {
print "$dbname is not writable!\n";
exit(1);
}
my $TYPEDEF = "i a$MAX_NOTE a$MAX_TIME";
my $SIZEOF = length pack($TYPEDEF, () );
$self->{version} = "(NOTEDB::binary, 1.7)";
$self->{NOTEDB} = $dbname;
my $TYPEDEF = "i a$MAX_NOTE a$MAX_TIME";
my $SIZEOF = length pack($TYPEDEF, () );
$sizeof = $SIZEOF;
$typedef = $TYPEDEF;
$self->{sizeof} = $SIZEOF;
$self->{typedef} = $TYPEDEF;
return $self;
return $self;
}
sub DESTROY
{
# clean the desk!
# clean the desk!
}
sub version {
return $version;
my $this = shift;
return $this->{version};
}
sub set_del_all
{
unlink $NOTEDB;
open(TT,">$NOTEDB") or die "Could not create $NOTEDB: $!\n";
close (TT);
my $this = shift;
unlink $this->{NOTEDB};
open(TT,">$this->{NOTEDB}") or die "Could not create $this->{NOTEDB}: $!\n";
close (TT);
}
sub get_single {
my($this, $num) = @_;
my($address, $note, $date, $buffer, $n, $t, $buffer, );
my($this, $num) = @_;
my($address, $note, $date, $buffer, $n, $t, $buffer, );
open NOTE, "+<$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
open NOTE, "+<$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
$address = ($num-1) * $sizeof;
seek(NOTE, $address, IO::Seekable::SEEK_SET);
read(NOTE, $buffer, $sizeof);
($num, $n, $t) = unpack($typedef, $buffer);
$address = ($num-1) * $this->{sizeof};
seek(NOTE, $address, IO::Seekable::SEEK_SET);
read(NOTE, $buffer, $this->{sizeof});
($num, $n, $t) = unpack($this->{typedef}, $buffer);
$note = ude($n);
$date = ude($t);
$note = $this->ude($n);
$date = $this->ude($t);
flock NOTE, LOCK_UN;
close NOTE;
flock NOTE, LOCK_UN;
close NOTE;
return $note, $date;
return $note, $date;
}
sub get_all
{
my $this = shift;
my($num, $note, $date, %res);
my $this = shift;
my($num, $note, $date, %res);
if ($this->unchanged) {
return %{$this->{cache}};
}
open NOTE, "+<$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
my($buffer, $t, $n);
seek(NOTE, 0, 0); # START FROM BEGINNING
while(read(NOTE, $buffer, $sizeof)) {
($num, $note, $date) = unpack($typedef, $buffer);
$t = ude($date);
$n = ude($note);
$res{$num}->{'note'} = $n;
$res{$num}->{'date'} = $t;
}
flock NOTE, LOCK_UN;
close NOTE;
if ($this->unchanged) {
return %{$this->{cache}};
}
open NOTE, "+<$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
my($buffer, $t, $n);
seek(NOTE, 0, 0); # START FROM BEGINNING
while(read(NOTE, $buffer, $this->{sizeof})) {
($num, $note, $date) = unpack($this->{typedef}, $buffer);
$t = $this->ude($date);
$n = $this->ude($note);
$res{$num}->{'note'} = $n;
$res{$num}->{'date'} = $t;
}
flock NOTE, LOCK_UN;
close NOTE;
$this->cache(%res);
return %res;
$this->cache(%res);
return %res;
}
sub get_nextnum
{
my $this = shift;
my($num, $te, $me, $buffer);
my $this = shift;
my($num, $te, $me, $buffer);
if ($this->unchanged) {
$num = 1;
foreach (keys %{$this->{cache}}) {
$num++;
}
return $num;
if ($this->unchanged) {
$num = 1;
foreach (keys %{$this->{cache}}) {
$num++;
}
open NOTE, "+<$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
while(read(NOTE, $buffer, $sizeof)) {
($num, $te, $me) = unpack($typedef, $buffer);
}
$num += 1;
flock NOTE, LOCK_UN;
close NOTE;
return $num;
}
open NOTE, "+<$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
while(read(NOTE, $buffer, $this->{sizeof})) {
($num, $te, $me) = unpack($this->{typedef}, $buffer);
}
$num += 1;
flock NOTE, LOCK_UN;
close NOTE;
return $num;
}
sub get_search
{
my($this, $searchstring) = @_;
my($buffer, $num, $note, $date, %res, $t, $n, $match);
my($this, $searchstring) = @_;
my($buffer, $num, $note, $date, %res, $t, $n, $match);
my $regex = $this->generate_search($searchstring);
eval $regex;
if ($@) {
print "invalid expression: \"$searchstring\"!\n";
return;
}
$match = 0;
my $regex = $this->generate_search($searchstring);
eval $regex;
if ($@) {
print "invalid expression: \"$searchstring\"!\n";
return;
}
$match = 0;
if ($this->unchanged) {
foreach my $num (keys %{$this->{cache}}) {
$_ = $this->{cache}{$num}->{note};
eval $regex;
if ($match) {
$res{$num}->{note} = $this->{cache}{$num}->{note};
$res{$num}->{date} = $this->{cache}{$num}->{date}
}
$match = 0;
if ($this->unchanged) {
foreach my $num (keys %{$this->{cache}}) {
$_ = $this->{cache}{$num}->{note};
eval $regex;
if ($match) {
$res{$num}->{note} = $this->{cache}{$num}->{note};
$res{$num}->{date} = $this->{cache}{$num}->{date}
}
return %res;
$match = 0;
}
open NOTE, "+<$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
while(read(NOTE, $buffer, $sizeof))
{
($num, $note, $date) = unpack($typedef, $buffer);
$n = ude($note);
$t = ude($date);
$_ = $n;
eval $regex;
if($match)
{
$res{$num}->{'note'} = $n;
$res{$num}->{'date'} = $t;
}
$match = 0;
}
flock NOTE, LOCK_UN;
close NOTE;
return %res;
}
open NOTE, "+<$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
while(read(NOTE, $buffer, $this->{sizeof})) {
($num, $note, $date) = unpack($this->{typedef}, $buffer);
$n = $this->ude($note);
$t = $this->ude($date);
$_ = $n;
eval $regex;
if($match)
{
$res{$num}->{'note'} = $n;
$res{$num}->{'date'} = $t;
}
$match = 0;
}
flock NOTE, LOCK_UN;
close NOTE;
return %res;
}
@@ -200,132 +194,135 @@ sub get_search
sub set_edit
{
my($this, $num, $note, $date) = @_;
my $address = ($num -1 ) * $sizeof;
my($this, $num, $note, $date) = @_;
my $address = ($num -1 ) * $this->{sizeof};
open NOTE, "+<$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
open NOTE, "+<$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
seek(NOTE, $address, IO::Seekable::SEEK_SET);
my $n = uen($note);
my $t = uen($date);
seek(NOTE, $address, IO::Seekable::SEEK_SET);
my $n = $this->uen($note);
my $t = $this->uen($date);
my $buffer = pack($typedef, $num, $n, $t);
print NOTE $buffer;
my $buffer = pack($this->{typedef}, $num, $n, $t);
print NOTE $buffer;
flock NOTE, LOCK_UN;
close NOTE;
flock NOTE, LOCK_UN;
close NOTE;
$this->changed;
$this->changed;
}
sub set_new
{
my($this, $num, $note, $date) = @_;
open NOTE, "+<$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
my($this, $num, $note, $date) = @_;
open NOTE, "+<$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, IO::Seekable::SEEK_END); # APPEND
my $n = uen($note);
my $t = uen($date);
my $buffer = pack($typedef, $num, $n, $t);
print NOTE $buffer;
seek(NOTE, 0, IO::Seekable::SEEK_END); # APPEND
my $n = $this->uen($note);
my $t = $this->uen($date);
my $buffer = pack($this->{typedef}, $num, $n, $t);
print NOTE $buffer;
flock NOTE, LOCK_UN;
close NOTE;
flock NOTE, LOCK_UN;
close NOTE;
$this->changed;
$this->changed;
}
sub set_del
{
my($this, $num) = @_;
my(%orig, $note, $date, $T, $setnum, $buffer, $n, $N, $t);
my($this, $num) = @_;
my(%orig, $note, $date, $T, $setnum, $buffer, $n, $N, $t);
$setnum = 1;
$setnum = 1;
%orig = $this->get_all();
return "ERROR" if (! exists $orig{$num});
%orig = $this->get_all();
return "ERROR" if (! exists $orig{$num});
delete $orig{$num};
delete $orig{$num};
# overwrite, but keep number!
open NOTE, ">$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
foreach $N (keys %orig) {
$n = uen($orig{$N}->{'note'});
$t = uen($orig{$N}->{'date'});
$buffer = pack( $typedef, $N, $n, $t); # keep orig number, note have to call recount!
print NOTE $buffer;
seek(NOTE, 0, IO::Seekable::SEEK_END);
$setnum++;
}
flock NOTE, LOCK_UN;
close NOTE;
# overwrite, but keep number!
open NOTE, ">$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
foreach $N (keys %orig) {
$n = $this->uen($orig{$N}->{'note'});
$t = $this->uen($orig{$N}->{'date'});
$buffer = pack( $this->{typedef}, $N, $n, $t);
# keep orig number, note have to call recount!
print NOTE $buffer;
seek(NOTE, 0, IO::Seekable::SEEK_END);
$setnum++;
}
flock NOTE, LOCK_UN;
close NOTE;
$this->changed;
$this->changed;
return;
return;
}
sub set_recountnums
{
my($this) = @_;
my(%orig, $note, $date, $T, $setnum, $buffer, $n, $N, $t);
my($this) = @_;
my(%orig, $note, $date, $T, $setnum, $buffer, $n, $N, $t);
$setnum = 1;
%orig = $this->get_all();
$setnum = 1;
%orig = $this->get_all();
open NOTE, ">$NOTEDB" or die "could not open $NOTEDB\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
open NOTE, ">$this->{NOTEDB}" or die "could not open $this->{NOTEDB}\n";
flock NOTE, LOCK_EX;
seek(NOTE, 0, 0); # START FROM BEGINNING
foreach $N (sort {$a <=> $b} keys %orig) {
$n = uen($orig{$N}->{'note'});
$t = uen($orig{$N}->{'date'});
$buffer = pack( $typedef, $setnum, $n, $t);
print NOTE $buffer;
seek(NOTE, 0, IO::Seekable::SEEK_END);
$setnum++;
}
flock NOTE, LOCK_UN;
close NOTE;
foreach $N (sort {$a <=> $b} keys %orig) {
$n = $this->uen($orig{$N}->{'note'});
$t = $this->uen($orig{$N}->{'date'});
$buffer = pack( $this->{typedef}, $setnum, $n, $t);
print NOTE $buffer;
seek(NOTE, 0, IO::Seekable::SEEK_END);
$setnum++;
}
flock NOTE, LOCK_UN;
close NOTE;
$this->changed;
$this->changed;
return;
return;
}
sub uen
{
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = pack("u", $cipher->encrypt($_[0]));
};
}
else {
$T = pack("u", $_[0]);
}
chomp $T;
return $T;
my $this = shift;
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = pack("u", $this->{cipher}->encrypt($_[0]));
};
}
else {
$T = pack("u", $_[0]);
}
chomp $T;
return $T;
}
sub ude
{
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = $cipher->decrypt(unpack("u",$_[0]));
};
}
else {
$T = unpack("u", $_[0]);
}
return $T;
my $this = shift;
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = $this->{cipher}->decrypt(unpack("u",$_[0]));
};
}
else {
$T = unpack("u", $_[0]);
}
return $T;
}

197
NOTEDB/dbm.pm
View File

@@ -1,180 +1,187 @@
#!/usr/bin/perl
# $Id: dbm.pm,v 1.1.1.1 2000/07/01 14:40:52 zarahg Exp $
# $Id: dbm.pm,v 1.3 2000/08/11 00:05:58 zarahg Exp $
# Perl module for note
# DBM database backend. see docu: perldoc NOTEDB::dbm
#
package NOTEDB;
use DB_File;
#use Data::Dumper;
use Data::Dumper;
use NOTEDB;
use strict;
package NOTEDB;
# Globals:
my ($dbm_dir, $notefile, $timefile, $version, $cipher, %note, %date);
$notefile = "note.dbm";
$timefile = "date.dbm";
my (%note, %date);
$version = "(NOTEDB::dbm, 1.1)";
sub new
{
my($this, $dbdriver, $dbm_dir) = @_;
my $class = ref($this) || $this;
my $self = {};
bless($self,$class);
my($this, $dbdriver, $dbm_dir) = @_;
my $class = ref($this) || $this;
my $self = {};
bless($self,$class);
tie %note, "DB_File", "$dbm_dir/$notefile" || die $!;
tie %date, "DB_File", "$dbm_dir/$timefile" || die $!;
my $notefile = "note.dbm";
my $timefile = "date.dbm";
$self->{version} = "(NOTEDB::dbm, 1.2)";
return $self;
tie %note, "DB_File", "$dbm_dir/$notefile" || die $!;
tie %date, "DB_File", "$dbm_dir/$timefile" || die $!;
return $self;
}
sub DESTROY
{
# clean the desk!
untie %note, %date;
# clean the desk!
untie %note, %date;
}
sub version {
return $version;
my $this = shift;
return $this->{version};
}
sub get_single
sub get_single
{
my($this, $num) = @_;
my($note, $date);
return ude ($note{$num}), ude($date{$num});
my($this, $num) = @_;
my($note, $date);
return $this->ude ($note{$num}), $this->ude($date{$num});
}
sub get_all
{
my($this, $num, $note, $date, %res, $real);
foreach $num (sort {$a <=> $b} keys %date) {
$res{$num}->{'note'} = ude($note{$num});
$res{$num}->{'date'} = ude($date{$num});
}
return %res;
my $this = shift;
my($num, $note, $date, %res, $real);
foreach $num (sort {$a <=> $b} keys %date) {
$res{$num}->{'note'} = $this->ude($note{$num});
$res{$num}->{'date'} = $this->ude($date{$num});
}
return %res;
}
sub get_nextnum
{
my($this, $num);
foreach (sort {$a <=> $b} keys %date) {
$num = $_;
}
$num++;
return $num;
my($this, $num);
foreach (sort {$a <=> $b} keys %date) {
$num = $_;
}
$num++;
return $num;
}
sub get_search
{
my($this, $searchstring) = @_;
my($num, $note, $date, %res, $match);
my($this, $searchstring) = @_;
my($num, $note, $date, %res, $match);
my $regex = $this->generate_search($searchstring);
my $regex = $this->generate_search($searchstring);
eval $regex;
if ($@) {
print "invalid expression: \"$searchstring\"!\n";
return;
}
$match = 0;
foreach $num (sort {$a <=> $b} keys %date) {
$_ = $this->ude($note{$num});
eval $regex;
if ($@) {
print "invalid expression: \"$searchstring\"!\n";
return;
if ($match) {
$res{$num}->{'note'} = $this->ude($note{$num});
$res{$num}->{'date'} = $this->ude($date{$num});
}
$match = 0;
foreach $num (sort {$a <=> $b} keys %date) {
$_ = ude($note{$num});
eval $regex;
if ($match) {
$res{$num}->{'note'} = ude($note{$num});
$res{$num}->{'date'} = ude($date{$num});
}
$match = 0;
}
}
return %res;
return %res;
}
sub set_recountnums
{
my $this = shift;
my(%Note, %Date, $num, $setnum);
$setnum = 1;
foreach $num (sort {$a <=> $b} keys %note) {
$Note{$setnum} = $note{$num};
$Date{$setnum} = $date{$num};
$setnum++;
}
%note = %Note;
%date = %Date;
my $this = shift;
my(%Note, %Date, $num, $setnum);
$setnum = 1;
foreach $num (sort {$a <=> $b} keys %note) {
$Note{$setnum} = $note{$num};
$Date{$setnum} = $date{$num};
$setnum++;
}
%note = %Note;
%date = %Date;
}
sub set_edit
{
my($this, $num, $note, $date) = @_;
$note{$num} = uen($note);
$date{$num} = uen($date);
my($this, $num, $note, $date) = @_;
$note{$num} = $this->uen($note);
$date{$num} = $this->uen($date);
}
sub set_new
{
my($this, $num, $note, $date) = @_;
$this->set_edit($num, $note, $date); # just the same thing
my($this, $num, $note, $date) = @_;
$this->set_edit($num, $note, $date); # just the same thing
}
sub set_del
{
my($this, $num) = @_;
my($note, $date, $T);
($note, $date) = $this->get_single($num);
return "ERROR" if ($date !~ /^\d/);
delete $note{$num};
delete $date{$num};
my($this, $num) = @_;
my($note, $date, $T);
($note, $date) = $this->get_single($num);
return "ERROR" if ($date !~ /^\d/);
delete $note{$num};
delete $date{$num};
}
sub set_del_all
{
my($this) = @_;
%note = ();
%date = ();
return;
my($this) = @_;
%note = ();
%date = ();
return;
}
sub uen
{
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = pack("u", $cipher->encrypt($_[0]));
};
}
else {
$T = $_[0];
}
chomp $T;
return $T;
my $this = shift;
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = pack("u", $this->{cipher}->encrypt($_[0]));
};
}
else {
$T = $_[0];
}
chomp $T;
return $T;
}
sub ude
{
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = $cipher->decrypt(unpack("u",$_[0]))
};
return $T;
}
else {
return $_[0];
}
my $this = shift;
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = $this->{cipher}->decrypt(unpack("u",$_[0]))
};
return $T;
}
else {
return $_[0];
}
}

381
NOTEDB/mysql.pm
View File

@@ -1,174 +1,192 @@
#!/usr/bin/perl
# $Id: mysql.pm,v 1.1.1.1 2000/07/01 14:40:52 zarahg Exp $
# $Id: mysql.pm,v 1.3 2000/08/11 00:05:58 zarahg Exp $
# Perl module for note
# mysql database backend. see docu: perldoc NOTEDB::binary
# mysql database backend. see docu: perldoc NOTEDB::mysql
#
package NOTEDB;
use DBI;
use strict;
use Data::Dumper;
use NOTEDB;
package NOTEDB;
# Globals:
my ($DB, $table, $fnum, $fnote, $fdate, $version, $cipher);
$table = "note";
$fnum = "number";
$fnote = "note";
$fdate = "date";
$version = "(NOTEDB::mysql, 1.4)";
# prepare some std statements... #####################################################################
my $sql_getsingle = "SELECT $fnote,$fdate FROM $table WHERE $fnum = ?";
my $sql_all = "SELECT $fnum,$fnote,$fdate FROM $table";
my $sql_nextnum = "SELECT max($fnum) FROM $table";
my $sql_incrnum = "SELECT $fnum FROM $table ORDER BY $fnum";
my $sql_setnum = "UPDATE $table SET $fnum = ? WHERE $fnum = ?";
my $sql_edit = "UPDATE $table SET $fnote = ?, $fdate = ? WHERE $fnum = ?";
my $sql_insertnew = "INSERT INTO $table VALUES (?, ?, ?)";
my $sql_del = "DELETE FROM $table WHERE $fnum = ?";
my $sql_del_all = "DELETE FROM $table";
######################################################################################################
sub new
{
# no prototype, because of the bin-version, which takes only a filename!
my($this, $dbdriver, $dbname, $dbhost, $dbuser, $dbpasswd) = @_;
# no prototype, because of the bin-version, which takes only a filename!
my $class = ref($this) || $this;
my $self = {};
bless($self,$class);
my $database = "DBI:$dbdriver:$dbname;host=$dbhost";
my($this, $dbdriver, $dbname, $dbhost, $dbuser, $dbpasswd,
$table, $fnum, $fnote, $fdate, $dbport) = @_;
$DB = DBI->connect($database, $dbuser, $dbpasswd) || die DBI->errstr();
return $self;
my $class = ref($this) || $this;
my $self = {};
bless($self,$class);
my $database;
if ($dbport) {
$database = "DBI:$dbdriver:$dbname;host=$dbhost:$dbport";
}
else {
$database = "DBI:$dbdriver:$dbname;host=$dbhost";
}
$self->{version} = "(NOTEDB::mysql, 1.5)";
$self->{table} = $table;
$self->{sql_getsingle} = "SELECT $fnote,$fdate FROM $self->{table} WHERE $fnum = ?";
$self->{sql_all} = "SELECT $fnum,$fnote,$fdate FROM $self->{table}";
$self->{sql_nextnum} = "SELECT max($fnum) FROM $self->{table}";
$self->{sql_incrnum} = "SELECT $fnum FROM $self->{table} ORDER BY $fnum";
$self->{sql_setnum} = "UPDATE $self->{table} SET $fnum = ? WHERE $fnum = ?";
$self->{sql_edit} = "UPDATE $self->{table} SET $fnote = ?,$fdate = ? WHERE $fnum = ?";
$self->{sql_insertnew} = "INSERT INTO $self->{table} VALUES (?, ?, ?)";
$self->{sql_del} = "DELETE FROM $self->{table} WHERE $fnum = ?";
$self->{sql_del_all} = "DELETE FROM $self->{table}";
$self->{DB} = DBI->connect($database, $dbuser, $dbpasswd) or die DBI->errstr();
return $self;
}
sub DESTROY
{
# clean the desk!
# clean the desk!
my $this = shift;
$this->{DB}->disconnect;
}
sub lock {
my($this) = @_;
# LOCK the database!
my $lock = $DB->prepare("LOCK TABLES $table WRITE") || die $DB->errstr();
$lock->execute() || die $DB->errstr();
my($this) = @_;
# LOCK the database!
my $lock = $this->{DB}->prepare("LOCK TABLES $this->{table} WRITE")
|| die $this->{DB}->errstr();
$lock->execute() || die $this->{DB}->errstr();
}
sub unlock {
my($this) = @_;
my $unlock = $DB->prepare("UNLOCK TABLES") || die $DB->errstr;
$unlock->execute() || die $DB->errstr();
$DB->disconnect || die $DB->errstr;
my($this) = @_;
my $unlock = $this->{DB}->prepare("UNLOCK TABLES") || die $this->{DB}->errstr;
$unlock->execute() || die $this->{DB}->errstr();
}
sub version {
return $version;
my $this = shift;
return $this->{version};
}
sub get_single {
my($this, $num) = @_;
my($this, $num) = @_;
my($note, $date);
my $statement = $DB->prepare($sql_getsingle) || die $DB->errstr();
my($note, $date);
my $statement = $this->{DB}->prepare($this->{sql_getsingle}) || die $this->{DB}->errstr();
$statement->execute($num) || die $DB->errstr();
$statement->bind_columns(undef, \($note, $date)) || die $DB->errstr();
$statement->execute($num) || die $this->{DB}->errstr();
$statement->bind_columns(undef, \($note, $date)) || die $this->{DB}->errstr();
while($statement->fetch) {
return ude($note), ude($date);
}
while($statement->fetch) {
return $this->ude($note), $this->ude($date);
}
}
sub get_all
{
my $this = shift;
my($num, $note, $date, %res);
my $this = shift;
my($num, $note, $date, %res);
if ($this->unchanged) {
return %{$this->{cache}};
}
if ($this->unchanged) {
return %{$this->{cache}};
}
my $statement = $DB->prepare($sql_all) || die $DB->errstr();
my $statement = $this->{DB}->prepare($this->{sql_all}) or die $this->{DB}->errstr();
$statement->execute || die $DB->errstr();
$statement->bind_columns(undef, \($num, $note, $date)) || die $DB->errstr();
$statement->execute or die $this->{DB}->errstr();
$statement->bind_columns(undef, \($num, $note, $date)) or die $this->{DB}->errstr();
while($statement->fetch) {
$res{$num}->{'note'} = ude($note);
$res{$num}->{'date'} = ude($date);
}
while($statement->fetch) {
$res{$num}->{'note'} = $this->ude($note);
$res{$num}->{'date'} = $this->ude($date);
}
$this->cache(%res);
return %res;
$this->cache(%res);
return %res;
}
sub get_nextnum
{
my($this, $num);
if ($this->unchanged) {
$num = 1;
foreach (keys %{$this->{cache}}) {
$num++;
}
return $num;
my $this = shift;
my($num);
if ($this->unchanged) {
$num = 1;
foreach (keys %{$this->{cache}}) {
$num++;
}
return $num;
}
my $statement = $DB->prepare($sql_nextnum) || die $DB->errstr();
my $statement = $this->{DB}->prepare($this->{sql_nextnum}) || die $this->{DB}->errstr();
$statement->execute || die $DB->errstr();
$statement->bind_columns(undef, \($num)) || die $DB->errstr();
$statement->execute || die $this->{DB}->errstr();
$statement->bind_columns(undef, \($num)) || die $this->{DB}->errstr();
while($statement->fetch) {
return $num+1;
}
while($statement->fetch) {
return $num+1;
}
}
sub get_search
{
my($this, $searchstring) = @_;
my($num, $note, $date, %res, $match);
my($this, $searchstring) = @_;
my($num, $note, $date, %res, $match, $use_cache);
my $regex = $this->generate_search($searchstring);
my $regex = $this->generate_search($searchstring);
eval $regex;
if ($@) {
print "invalid expression: \"$searchstring\"!\n";
return;
}
$match = 0;
if ($this->unchanged) {
foreach my $num (keys %{$this->{cache}}) {
$_ = $this->{cache}{$num}->{note};
eval $regex;
if ($match) {
$res{$num}->{note} = $this->{cache}{$num}->{note};
$res{$num}->{date} = $this->{cache}{$num}->{date}
}
$match = 0;
}
return %res;
}
my $statement = $this->{DB}->prepare($this->{sql_all}) or die $this->{DB}->errstr();
$statement->execute or die $this->{DB}->errstr();
$statement->bind_columns(undef, \($num, $note, $date)) or die $this->{DB}->errstr();
while($statement->fetch) {
$note = $this->ude($note);
$date = $this->ude($date);
$_ = $note;
eval $regex;
if ($@) {
print "invalid expression: \"$searchstring\"!\n";
return;
}
$match = 0;
my %data;
if ($this->unchanged) {
%data = %{$this->{cache}};
}
else {
%data = $this->get_all();
}
foreach $num (sort { $a <=> $b } keys %data) {
$note = ude($data{$num}->{'note'});
$date = ude($data{$num}->{'date'});
$_ = $note;
eval $regex;
if($match) {
if($match) {
$res{$num}->{'note'} = $note;
$res{$num}->{'date'} = $date;
}
$match = 0;
}
return %res;
$match = 0;
}
return %res;
}
@@ -176,116 +194,119 @@ sub get_search
sub set_edit
{
my($this, $num, $note, $date) = @_;
my($this, $num, $note, $date) = @_;
$this->lock;
my $statement = $DB->prepare($sql_edit) || die $DB->errstr();
$note =~ s/'/\'/g;
$note =~ s/\\/\\\\/g;
$statement->execute(uen($note), uen($date), $num) || die $DB->errstr();
$this->unlock;
$this->changed;
$this->lock;
my $statement = $this->{DB}->prepare($this->{sql_edit}) or die $this->{DB}->errstr();
$note =~ s/'/\'/g;
$note =~ s/\\/\\\\/g;
$statement->execute($this->uen($note), $this->uen($date), $num)
or die $this->{DB}->errstr();
$this->unlock;
$this->changed;
}
sub set_new
{
my($this, $num, $note, $date) = @_;
$this->lock;
my $statement = $DB->prepare($sql_insertnew) || die $DB->errstr();
my($this, $num, $note, $date) = @_;
$this->lock;
my $statement = $this->{DB}->prepare($this->{sql_insertnew}) || die $this->{DB}->errstr();
$note =~ s/'/\'/g;
$note =~ s/\\/\\\\/g;
$statement->execute($num, uen($note), uen($date)) || die $DB->errstr();
$this->unlock;
$this->changed;
$note =~ s/'/\'/g;
$note =~ s/\\/\\\\/g;
$statement->execute($num, $this->uen($note), $this->uen($date)) || die $this->{DB}->errstr();
$this->unlock;
$this->changed;
}
sub set_del
{
my($this, $num) = @_;
my($note, $date, $T);
my($this, $num) = @_;
my($note, $date, $T);
$this->lock;
($note, $date) = $this->get_single($num);
$this->lock;
($note, $date) = $this->get_single($num);
return "ERROR" if ($date !~ /^\d/);
return "ERROR" if ($date !~ /^\d/);
# delete record!
my $statement = $DB->prepare($sql_del) || die $DB->errstr();
$statement->execute($num) || die $DB->errstr();
$this->unlock;
$this->changed;
return;
# delete record!
my $statement = $this->{DB}->prepare($this->{sql_del}) || die $this->{DB}->errstr();
$statement->execute($num) || die $this->{DB}->errstr();
$this->unlock;
$this->changed;
return;
}
sub set_del_all
{
my($this) = @_;
$this->lock;
my $statement = $DB->prepare($sql_del_all) || die $DB->errstr();
$statement->execute() || die $DB->errstr();
$this->unlock;
$this->changed;
return;
my($this) = @_;
$this->lock;
my $statement = $this->{DB}->prepare($this->{sql_del_all}) || die $this->{DB}->errstr();
$statement->execute() || die $this->{DB}->errstr();
$this->unlock;
$this->changed;
return;
}
sub set_recountnums {
my $this = shift;
my $this = shift;
$this->lock;
$this->lock;
my(@count, $i, $num, $setnum, $pos);
$setnum = 1;
$pos=0; $i=0; @count = ();
my(@count, $i, $num, $setnum, $pos);
$setnum = 1;
$pos=0; $i=0; @count = ();
my $statement = $DB->prepare($sql_incrnum) || die $DB->errstr();
$statement->execute || die $DB->errstr();
$statement->bind_columns(undef, \($num)) || die $DB->errstr();
# store real id's in an array!
while($statement->fetch) {
$count[$i] = $num;
$i++;
}
# now recount them!
my $sub_statement = $DB->prepare($sql_setnum) || die $DB->errstr();
for($pos=0;$pos<$i;$pos++) {
$setnum = $pos +1;
$sub_statement->execute($setnum,$count[$pos]) || die $DB->errstr();
}
$this->unlock;
$this->changed;
my $statement = $this->{DB}->prepare($this->{sql_incrnum}) || die $this->{DB}->errstr();
$statement->execute || die $this->{DB}->errstr();
$statement->bind_columns(undef, \($num)) || die $this->{DB}->errstr();
# store real id's in an array!
while($statement->fetch) {
$count[$i] = $num;
$i++;
}
# now recount them!
my $sub_statement = $this->{DB}->prepare($this->{sql_setnum}) || die $this->{DB}->errstr();
for($pos=0;$pos<$i;$pos++) {
$setnum = $pos +1;
$sub_statement->execute($setnum,$count[$pos]) || die $this->{DB}->errstr();
}
$this->unlock;
$this->changed;
}
sub uen
{
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = pack("u", $cipher->encrypt($_[0]));
};
}
else {
$T = $_[0];
}
chomp $T;
return $T;
my $this = shift;
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = pack("u", $this->{cipher}->encrypt($_[0]));
};
}
else {
$T = $_[0];
}
chomp $T;
return $T;
}
sub ude
{
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = $cipher->decrypt(unpack("u",$_[0]))
};
return $T;
}
else {
return $_[0];
}
my $this = shift;
my($T);
if($NOTEDB::crypt_supported == 1) {
eval {
$T = $this->{cipher}->decrypt(unpack("u",$_[0]))
};
return $T;
}
else {
return $_[0];
}
}
1; # keep this!