Free relations query software for linux

Relations::Query is a Perl Object for building queries with DBI/DBD::mysql.

SYNOPSIS

# Relations::Query Script that creates some queries.

use Relations::Query;

$query = new Relations::Query(-select => {fife => barney},
-from => {green_teeth => moogoo},
-where => "flotsam>jetsam",
-group_by => "denali",
-having => {fortune => cookie},
-order_by => [was,is,will],
-limit => 1);

$get_query = $query->get();

$query->set(-select => {clean => sparkle},
-from => {lean => book},
-where => "fighting is between courage and chaos",
-limit => 123);

$set_query = $query->get();

$get_add_query = $query->get_add(-select => {mean => dog},
-where => "running is null",
-having => {kitties=> on_tv},
-limit => [9678]);

$query = to_string({select => this,
from => that});

Relations::Display is a DBI/DBD::mysql Query Graphing Perl module.

SYNOPSIS

# DBI, Relations::Display Script that creates a
# matrix, table, and graph from a query.

use DBI;
use Relations;
use Relations::Query;
use Relations::Abstract;
use Relations::Display;

$dsn = "DBI:mysql:watcher";

$username = "root";
$password = ;

$dbh = DBI->connect($dsn,$username,$password,{PrintError => 1, RaiseError => 0});

$abstract = new Relations::Abstract($dbh);

$display = new Relations::Display(-abstract => $abstract,
-query => {-select => {total => "count(*)",
first => "Bird",
second => "Count",
third => "if(gender=Male,Boy,Girl)",
tao => "if(gender=Male,Yang,Yin)",
sex => "gender",
kind => "sp_name",
id => "species.sp_id",
fourth => "(species.sp_id+50)",
vert => "2",
horiz => "1.5"},
-from => [bird,species],
-where => [species.sp_id=bird.sp_id,
species.sp_id < 4],
-group_by => [sp_name,gender,first,second],
-order_by => [gender,sp_name]},
-x_axis => first,kind,id,fourth,
-legend => second,third,tao,sex,vert,horiz,
-y_axis => total,
-hide => fourth,third,vert,horiz,
-vertical => vert,
-horizontal => horiz);

$matrix = $display->get_matrix();

$table = $display->get_table();

$display->set(-chart => bars,
-width => 400,
-height => 400,
-settings => {y_min_value => 0,
y_max_value => 3,
y_tick_number => 3,
transparent => 0}
);

$gph = $display->get_graph();

$gd = $gph->gd();

open(IMG, >test.png) or die $!;
binmode IMG;
print IMG $gd->png;

$dbh->disconnect();

Relations::Family is a DBI/DBD::mysql Relational Query Engine module.

SYNOPSIS

# DBI, Relations::Family Script that creates some queries.

#!/usr/bin/perl

use DBI;
use Relations::Family;

$dsn = "DBI:mysql:finder";

$username = "root";
$password = ;

$dbh = DBI->connect($dsn,$username,$password,{PrintError => 1, RaiseError => 0});

$abstract = new Relations::Abstract($dbh);

$family = new Relations::Family($abstract);

$family->add_member(-name => account,
-label => Cust. Account,
-database => finder,
-table => account,
-id_field => acc_id,
-query => {-select => {id => acc_id,
label => "concat(cust_name, - ,balance)"},
-from => [account,customer],
-where => "customer.cust_id=account.cust_id",
-order_by => "cust_name"});

$family->add_member(-name => customer,
-label => Customer,
-database => finder,
-table => customer,
-id_field => cust_id,
-query => {-select => {id => cust_id,
label => cust_name},
-from => customer,
-order_by => "cust_name"});

$family->add_member(-name => purchase,
-label => Purchase,
-database => finder,
-table => purchase,
-id_field => pur_id,
-query => {-select => {id => pur_id,
label => "concat(
cust_name,
- ,
date_format(date, %M %D, %Y)
)"},
-from => [purchase,
customer],
-where => customer.cust_id=purchase.cust_id,
-order_by => [date desc,
cust_name]});

$family->add_lineage(-parent_name => customer,
-parent_field => cust_id,
-child_name => purchase,
-child_field => cust_id);

$family->add_rivalry(-brother_name => customer,
-brother_field => cust_id,
-sister_name => account,
-sister_field => cust_id);

$family->set_chosen(-label => Customer,
-ids => 2,4);

$available = $family->get_available(-label => Purchase);

print "Found $available->{count} Purchases:n";

foreach $id (@{$available->{ids_array}}) {

print "Id: $id Label: $available->{labels_hash}->{$id}n";

}

$family->add_value(-name => Cust. Account,
-sql => "concat(cust_name, - ,balance)",
-member_names => customer,account);

$family->add_value(-name => Paid,
-sql => "if(balance > 0,NO,YES)",
-member_names => account);

$family->add_value(-name => Customer,
-sql => cust_name,
-member_names => customer);

$family->add_value(-name => Purchase,
-sql => "concat(
cust_name,
- ,
date_format(date, %M %D, %Y)
)",
-member_names => purchase,customer);

$reunion = $family->get_reunion(-data => Paid,Purchase,
-use_labels => Customer,
-order_by => Customer,Purchase);

$matrix = $abstract->select_matrix(-query => $reunion);

print "Found " . scalar @$matrix . " Values:n";

foreach $row (@$matrix) {

print "Customer: $row->{Customer}n";
print "Purchase: $row->{Purchase}n";
print "Paid: $row->{Paid}nn";

}

$dbh->disconnect();

MySQL Query is a software web development.

You need MySQL installed in your PC.

OurNet::Query is a Perl module for scriptable queries with template extraction.

SYNOPSIS

use OurNet::Query;

# Set query parameters
my ($query, $hits) = (autrijus, 10);
my @sites = (google, google); # XXX: write more templates!
my %found;

# Generate a new Query object
my $bot = OurNet::Query->new($query, $hits, @sites);

# Perform a query
my $found = $bot->begin(&callback, 30); # Timeout after 30 seconds

print *** . ($found ? $found : No) . match(es) found.;

sub callback {
my %entry = @_;
my $entry = %entry;

unless ($found{$entry{url}}) {
print "*** [$entry->{title}]" .
" ($entry->{score})" .
" - [$entry->{id}]n" .
" URL: [$entry->{url}]n";
}

$found{$entry{url}}++;
}

This module provides an easy interface to perform multiple queries to internet services, and wraps them into your own format at once. The results are processed on-the-fly and are returned via callback functions.

Its interfaces resembles that of WWW::Searchs, but implements it in a different fashion. While WWW::Search relies on additional subclasses to parse returned results, OurNet::Query uses site descriptors for search search engine, which makes it much easier to add new backends.

Site descriptors may be written in XML, Template toolkit format, or the .fmt format from the commercial Inforia Quest product.

Konq Rellinks is an add-on for Konqueror, the official KDE browser.
It allows you to access the relations defined in the header of the document. These relations can be links to other versions of the document, RSS backend, search page, copyright informations,.... For more informations about this, see The link-Element in (X)HTML .
The look of the Rellinks add-on is similar to the "Site Navigation Toolbar" of the Mozilla browser (not Mozilla Firebird).
Enhancements:
- Support for "target" attribute,
- Distinction between "rel" and "rev" relations

Object::Relation::Meta::Type is an Object::Relation Data type validation and accessor building.

Synopsis

Object::Relation::Meta::Type->add(
key => "state",
name => "State",
builder => Object::Relation::Meta::AccessorBuilder,
raw => sub { ref $_[0] ? shift->value : shift },
store_raw => sub { shift->store_value },
check => sub {
UNIVERSAL::isa($_[0], Object::Relation::DataType::State)
or throw_invalid([Value "[_1]" is not a valid [_2] object,
$_[0], Object::Relation::DataType::State]);
throw_invalid([Cannot assign permanent state])
if $_[0] == Object::Relation::DataType::State->PERMANENT;
}
);

This class subclasses Class::Meta::Type to provide additional attributes. These attributes can optionally be set via the call to new(), and may be fetched via their accessors.

Object::Relation::DataType is a Perl module with complex data types for TKP.

The Object::Relation::DataType name space is set aside for the creation of complex data types for TKP. By "complex" I mean serializable objects, such as dates, durations, states, etc. It also is designed to create a distinction from simpler data types, which are defined in Object::Relation::Meta::DataTypes.

What creates the distinction? Well, first and foremost is that fact that it doesnt usually take much to create the simple data types, while the complex data types might need more code to handle serialization and deserialization, overloading, etc.

But another criterion is that, while the data types in Object::Relation::Meta::DataTypes are always loaded by TKP, since it uses them for its own classes, the complex data types in the Object::Relation::DataType name space tend to be loaded only as needed by the Object::Relation business classes that need them.

Okay, so its somewhat arbitrary, but you get the idea. The remainder of this document is dedicated to documenting how to add new data types to TKP.