This module provides methods for working with adjacency lists. The
adjacency list model is a very common way of representing a tree
structure. In this model each row in a table has a prent ID column
that references the primary key of another row in the same table.
Because of this the primary key must only be one column and is usually
some sort of integer. The row with a parent ID of 0 is the root node
and is usually the parent of all other rows. Although, there is no
limitation in this module that would stop you from having multiple
root nodes.
DBIx::NoSQL is a layer over DBI that presents a NoSQLish way to store and
retrieve data. It does this by using a table called __Store__. Once connected
to a database, it will detect if this table is missing and create it if
necessary.
When writing data to the store, the data (a HASH reference) is first
serialized using JSON and then inserted/updated via DBIx::Class to (currently)
an SQLite backend.
Retrieving data from the store is done by key lookup or by searching an
SQL-based index. Once found, the data is deserialized via JSON and returned.
DBIx::Simple module aims to be a simplified object oriented interface to Perl
DBI. From its description ...
Query preparation and execution are combined in a single method, the result
object (which is a wrapper around the statement handle) provides easy
row-by-row and slurping methods.
The "query" method returns either a result object, or a dummy object. The
dummy object returns undef (or an empty list) for all methods and when used in
boolean context, is false. The dummy object lets you postpone (or skip) error
checking, but it also makes immediate error check simply " $db->query(...) or
die $db->error".
RRDtool refers to round robin database tool. Round robin databases have
a fixed number of data points in them and contain a pointer to the
current element. Since the databases have a fixed number of data points
the database size doesn't change after creation. RRDtool allows you to
define a set of archives which consolidate the primary data points in
higher granularity. RRDtool is specialized for time series data and can
be used to create RRD files, update RRDs, retreive data from RRDs, and
generate graphs from the databases. This module provides a POE wrapper
around the rrdtool command line interface.
PgAccess is a pretty GUI (Graphical User Interface) for the open source
database PostgreSQL.
PgAccess is a cross-platform database management tool for PostgreSQL, written in
Tcl/Tk. There are active efforts to turn it into a tool for writing applications
that can work in a distributed client-server model (a central PostgreSQL
database and remote clients).
PgAccess was originally written by Constantin Teodorescu using Visual Tcl,
"the best tool for developing Tcl/Tk applications I've ever seen."
It is currently managed by the developers at BSDforge.com.
HyperSQL
HSQLDB is the leading SQL relational database engine written in Java. It has a
JDBC driver and supports a rich subset of ANSI-92 SQL (BNF tree format) plus
SQL 99 and 2003 enhancements. It offers a small (less than 100k in one version
for applets), fast database engine which offers both in-memory and disk-based
tables and supports embedded and server modes. Additionally, it includes tools
such as a minimal web server, in-memory query and management tools (can be run
as applets) and a number of demonstration examples.
A slider for the Xfce panel that can be used to adjust and/or monitor any
numeric variable. You set whatever "variable" this is by setting an adjust
command which will run when the slider is clicked or scrolled. An option is
provided to pass the value of the slider (the fraction times an adjustable
normalization factor) to the command. You get the value of the "variable" by
setting a sychronize command. The command should return a numeric value and this
value will be regarded as a fraction of a second adjustable normalization
factor.
CFFI, the Common Foreign Function Interface, purports to be a
portable foreign function interface for Common Lisp. The CFFI library
is composed of a Lisp-implementation-specific backend in the CFFI-SYS
package, and a portable frontend in the CFFI package.
The CFFI-SYS backend package defines a low-level interface to the
native FFI support in the Lisp implementation. It offers operators
for allocating and dereferencing foreign memory, calling foreign
functions, and loading shared libraries. The CFFI frontend provides
a declarative interface for defining foreign functions, structures,
typedefs, enumerated types, etc. It is implemented in portable ANSI
CL making use of the low-level operators exported by CFFI-SYS.
Log::Dispatch is a suite of OO modules for logging messages to multiple
outputs, each of which can have a minimum and maximum log level. It is
designed to be easily subclassed, both for creating a new dispatcher
object and particularly for creating new outputs.
It also allows both global (dispatcher level) and local (logging object)
message formatting callbacks which allows greater flexibility and should
reduce the need for subclassing.
Subclassing is only needed to send a message to a different output, not
to change the message format.
A program that takes as input a series of C source files and produces a
LaTeX or HTML document containing a cross reference of the
files/functions/variables in the program, including documentation taken
from suitably formatted source code comments.
The documentation is stored in the C source file in specially formatted
comments, making it simple to maintain. The cross referencing includes
lists of functions called, callers of each function, usage of global
variables, header file inclusion, macro definitions and type
definitions. Works for ANSI C, including a few gcc extensions.