Free queries software for linux

Be::Query is a Perl module to do a query for a given filesystem.

SYNOPSIS

use Be::Query;
@files = Be::Query::Query($filesystem, $query);

do a Query for a given filesystem

USAGE

@files = Be::Query::Query("/boot", "name=lib*.so");

$filesystem is a path anywhere in the target filesystem; $query is a query construction, of the form attribute op value [connector attribute op value]

Such as (name = fido) || (size >= 500)

Text::Query::BuildSQL is a base class for SQL query builders.

SYNOPSIS

package Text::Query::BuildSQLsqldb;

use Text::Query::BuildSQL;

use vars qw(@ISA);

@ISA = qw(Text::Query::BuildSQL);

Defines all the build_* functions to build a syntax tree. The tree nodes are [ operator scope operand operand... ]. The build_final_expression function translate the syntax tree in a where clause using the resolve method. If the scope of the search is not specified (simple query or advanced query without scope operator), the scope is set to the list of comma separated fields provided by the -fields_searched option. The resulting where clause is placed in the select order provided with the -select option, if any.

SYNTAX TREE

The string enclosed in single quotes must match exactly. The < string > token stands for an arbitrary string. A description enclosed in [something ...] means repeated 0 or N times.

expr: or scope expr [expr ...]
and scope expr [expr ...]
not scope expr
near scope expr_literal expr_literal
forbiden scope expr_literal [expr_literal ...]
mandatory scope expr_literal [expr_literal ...]
optional scope expr_literal [expr_literal ...]
literal scope < string >

expr_literal: literal scope < string >

scope: < string >

METHODS

resolve([], Q1)

Returns a where clause string corresponding to the Q1 syntax tree.

sortplusminus([], Q1)

Translate the mandatory and forbiden syntactic nodes to their boolean equivalents. If it has_relevance returns false and there is at least one mandatory word, the first mandatory word is added to the list of optional words.

has_relevance()

Returns true if relevance ranking is possible, false if not. It is used by the sortplusminus function. Returns false by default.

If relevance ranking is not possible, the semantic of the simple search is slighthly modified. When asking for +a b c it shows all the documents containing a and (b or c).

The normal behaviour is to return all the documents containing a and to sort them to show first those containing (b or c). When relevance ranking is not available the b, c search terms are therefore useless. That is why we decided to change the semantic of the query if no relevance ranking is available.

OPTIONS

-select STRING

If provided the string returned by build_final_expression substitutes the __WHERE__ tag with the where string generated by the resolve function. The substituted string is the return value of the build_final_expression.

If not set the return value of the build_final_expression is the result of the resolve function.

-fields_searched FIELDS_LIST

FIELDS_LIST is a list of comma separated field names. It is used as the default scope if no scope is provided in the query string. The build_final_expression function will croak if this option is not provided and no scope operator were used.

Practical Query Analyzer produces HTML reports on the most frequent queries, slowest queries, queries by type (select/insert/update/delete), and more for both PostgreSQL and MySQL log files.

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

pgFouine is a PostgreSQL log analyzer. It allows you to have a clear overview of your database activity, and can generate reports with slowest queries, most frequent queries, errors, graphs, and so on.

pgFouine is written in PHP and is designed to parse huge log files with a low memory footprint.

Example:
pgfouine.php -file path/to/your/log/file.log > report.html

For comprehensive usage information, just run:

pgfouine.php -help

QOF, the Query Object Framework, provides a set of C Language utilities for performing generic structured complex queries on a set of data held by a set of C/C++ objects.
Query Object Framework is unique in that it does NOT require SQL or any database at all to perform the query. Thus, it allows programmers to add query support to their applications without having to hook into an SQL Database.
Typically, if you have an app, and you want to add the ability to show a set of reports, you will need the ability to perform queries in order to get the data you need to show a report.
Of course, you can always write a set of ad-hoc subroutines to return the data that you need. But this kind of a programming style is not extensible: just wait till you get a user who wants a slightly different report.
The idea behind QOF is to provide a generic framework so that any query can be executed, including queries designed by the end-user.
Normally, this is possible only if you use a database that supports SQL, and then only if you deeply embed the database into your application. QOF provides simpler, more natural way to work with objects.
Enhancements:
- This release adds KVP_TYPE_BOOLEAN support, extensible error handling, and new Brazilian Portuguese and Indonesian translations.
- It fixes doxygen support (so that it can be disabled cleanly) and a sqlite error that resulted in spurious temporary files.
- It improves speed in the sqlite backend, packages the .pot file directly, and removes AM_MAINTAINER_MODE.
- QofError is designed for user-friendly messages and supports setting errors and error messages on-the-fly to provide user error messages that are as detailed, relevant, and helpful as possible.

Mergeant is a database administration tool.

Mergeant allows to connect to any database through the Libgda library (MySQL, PostgeSQL, Oracle, etc) and manage data within the database.

Any DML (data manipulation: insertion, update, deletion and selection) query can be created to help managing the data (queries can have optionnal parameters), from SQL statements or from a GUI interface.

The database structure (tables, data types, etc) can be browsed (modification is on the TODO list), and graphical representations of the database relations can be created.