CUBRID Apps Wiki

Sequel CUBRID Tutorial

2013-04-29T05:44:54-07:00

1. In order to install Sequel, you can run the following command:

gem install sequel

2. CUBRID can be installed using the cubrid gem:

gem install cubrid

For more information on installation visit the Ruby Driver Installation page.

3. To connect to a cubrid database, you can use one of the ruby lines below:

# if CUBRID is on localhost with default port
 DB = Sequel.cubrid('database_name')
 
 # A different host/port with username/password
 DB = Sequel.connect('cubrid://user:pass@host:port/database_name')

For some quick Sequel examples, check out the README.rdoc file.

Here is a complete example:

require 'rubygems'
require 'sequel'
require 'cubrid'

DB = Sequel.cubrid('demodb')

DB.create_table :items do
  primary_key :id
  String :name
  Float :price
end

items = DB[:items] # Create a dataset

# Populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# Print out the number of records
puts "Item count: #{items.count}"

# Print out the average price
puts "The average price is: #{items.avg(:price)}"

Sequel also supports connecting to CUBRID via JDBC if you are using JRuby. The only difference is you need to require the cubrid jar file separately, and you must change the connect line to:

require 'cubrid.jar'
DB = Sequel.connect('jdbc:cubrid:127.0.0.1:33000:sequel_test:::')

Apps for CUBRID

2012-01-09T17:52:07-08:00

This wiki is dedicated for third party applications (both Web and Desktop) which work with CUBRID Database Server.

Developers can promote their applications on this site by introducing their software, posting installation guides and tutorials, including download and support links.

This wiki will be moderated by the CUBRID team and the wiki contributors (the application developers).

You can search for applications based on these tags.

Programming language

Support

Multiple Database Cross-platform

Type

Web App Desktop App

Tagged

SQL Client SQL Query Builder Data Modeler Data Analysis ORM Whois

Sequel Key Features

2013-04-29T05:23:00-07:00

Sequel is a simple, flexible, and powerful SQL database access toolkit for Ruby.

Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.
Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.
Sequel currently has adapters for ADO, Amalgalite, CUBRID, DataObjects, DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLite3, Swift, and TinyTDS.

Sequel

2013-04-29T05:19:09-07:00

Sequel is a simple, flexible, and powerful SQL database access toolkit for Ruby.

[Sequel Key Features]
[Sequel CUBRID Tutorial]
Sequel Q&A
JIRA Issue Tracker

Kalkun - Open Source web based SMS Management

2013-04-29T04:28:37-07:00

Kalkun is an open source web-based SMS (Short Message Service) management. It uses gammu-smsd as SMS gateway engine to deliver and retrieve messages from your phone/modem. Kalkun and gammu are two different things. You have to install and configure gammu yourself. Kalkun only manages databases that are given by gammu.

[Kalkun Key Features]
[Kalkun CUBRID Tutorial]
Kalkun Q&A
JIRA Issue Tracker

Kalkun CUBRID Tutorial

2013-04-29T04:34:22-07:00

The Kalkun CUBRID Database can be created using the SQL found at the following link:

https://gist.github.com/back2arie/3095545

Kalkun Key Features

2013-04-29T04:31:17-07:00

Features

Multiple database backend (Currently supports CUBRID, MySQL, PostgreSQL and SQLite3)
Multiuser (each user have his/her own inbox, outbox, folder, and phonebook)
Conversation and SMS are grouped by phone number
Manage SMS (Inbox, Outbox, Sent Items)
Sending SMS, by person or group
Scheduled SMS, by datetime or delay
Manage Phonebook, by person or group
Create signature of your message
Create and manage private folder
Quick reply, reply, forward message
Flash/Long SMS
Simple Auto Reply
Unicode support
Localization (Currently available in English, Bahasa, Czech, Portuguese, Italian and Russian Language)

Plugin :

Blacklist Number, block message from specific number
Server Alert, receive an alert whenever your service (eq: Web server, Mail server) is down
SMS Bomber, send bomb/spam message

Hibernate ORM

2012-07-09T22:50:36-07:00

Hibernate is a collection of projects that enable developers to utilize POJO-style domain models in their applications in ways extending well beyond Object/Relational Mapping. For more information refer to Hibernate official home page.

Useful Links

Notice for CUBRIDDialect.java Update

Currently CUBRIDDialect.java file is in Hibernate Github repo of master branch only. Therefore your Hibernate ORM Pakage may have an old version of CUBRIDDialect.java file. We encourage you to override the older CUBRIDDialect.java file to the latest version and recompile it first.

You may find the old dialect file in your Hibernate package at:
hibernate-orm/hibernate-core/src/main/java/org/hibernate/dialect/CUBRIDDialect.java

In case you are using 3.6.x versions of Hibernate,

Hibernate 3.6 is no longer maintained by Hibernate Core team. However, if you still need fixes related to CUBRID Dialect, you can download the latest code from CUBRID Github repository:
https://github.com/CUBRID/hibernate-core/tree/3.6.
Or direct link to CUBRIDDialect.java:
https://github.com/CUBRID/hibernate-core/blob/3.6/hibernate-core/src/main/java/org/hibernate/dialect/CUBRIDDialect.java
You can also download the compiled Hibernate 3.6.11-SNAPSHOT JAR with the latest CUBRIDDialect.java from:
http://maven.cubrid.org/org/hibernate/hibernate-core/3.6.11-SNAPSHOT/

In case you are using 4.x versions of Hibernate,

Download the latest CUBRIDDialect.java, which is compatible with 4.0 or later versions of Hibernate, from the link below and then rebuild it:
http://sourceforge.net/projects/cubrid/files/CUBRID-AppsTools/HIBERNATE/3.6/CUBRIDDialect.java/download

In case you need CUBRIDDialect.java source code, refer to the following links:

The latest CUBRIDDialect.java file is in Hibernate Github repo of master branch:
https://github.com/hibernate/hibernate-orm/blob/master/hibernate-core/src/main/java/org/hibernate/dialect/CUBRIDDialect.java

Retrieve and Store Gmail Emails Using PHP IMAP and RedBeanPHP

2012-05-29T23:25:13-07:00

In this tutorial I will show how to use [RedBeanPHP - Easy ORM for PHP|RedBeanPHP] to easily store Gmail emails retrieved by PHP IMAP. RedBeanPHP supports CUBRID Database so we will use it as a database storage.

Scenario

This tutorial will have several steps.

First, we will make the appropriate preparation.
1. Install PHP IMAP extension.
2. Create a CUBRID database where we want to store our emails.
3. Referring to this database we will setup RedBean and establish a database connection.
Then retrieve all emails from our Gmail account.
INSERT and LOAD: To illustrate how to insert records into a table using RedBean, we will first create a bean (a new table record) and store only one attribute of an email (message_id). Once the bean is created, we will try to load it back from the database based on the returned id property.
Auto CREATE COLUMN and FIND: To show how RedBean automatically adjusts your database schema based on your code, we will add a second email attribute to the existing bean (subject). To find the existing bean, we will show how to find beans from the database.
Save special types: In RedBean Date is a special type. In this step we will add the date attribute of an email to the existing bean.

Step 1: Preparation

Install PHP IMAP

The extension which allows to work with IMAP protocol using PHP is not installed by default. In Ubuntu you can install it from the main repository:

sudo apt-get install php5-imap

On Mac OS X you can use Macports to install PHP IMAP extension:

sudo port install php5-imap

Create a CUBRID Database

This step assumes you have already installed CUBRID. Now, let's create a CUBRID database which we will call imap_redbean. In your terminal type:

cubrid createdb imap_redbean

This will create an imap_redbean database with a user dba and empty password (you can change the password later). Now make sure CUBRID Service is running, and then start the database.

cubrid service start
cubrid server start imap_redbean

Setup RedBean

Download RedBeanPHP. It is a one-file PHP script (rb.php). Extract the archive to find this file.

Now using your favorite source code editor (I use PHPStorm), create a PHP file (eg. imap_redbean.php). Include the rb.php and establish a database connection.

<?php
    /* first, we need to include redbean */
    require_once('rb.php');

    /* now connect to a CUBRID database */
    R::setup('cubrid:host=localhost;port=30000;dbname=imap_redbean', 'dba', '');
?>

Step 2: Retrieve all emails from Gmail

<?php
    /* first, we need to include redbean */
    require_once('rb.php');

    /* now connect to a CUBRID database */
    R::setup('cubrid:host=localhost;port=30000;dbname=imap_redbean', 'dba', '');

    /* connect to gmail */
    $hostname = '{imap.gmail.com:993/imap/ssl/novalidate-cert}INBOX';
    $username = 'mygmailusername';
    $password = 'mygmailpassword';

    /* try to connect */
    $inbox = imap_open($hostname, $username, $password) or die('Cannot connect to Gmail: ' . imap_last_error());

    /* grab ALL emails */
    $emails = imap_search($inbox, 'ALL');

    /* if emails are returned, cycle through each... */
    if($emails)
    {
        /* for every email... */
        foreach($emails as $email_number)
        {
            /*  get information specific to this email
                returns an array with the following properies:
                subject, from, to, date, message_id, references,
                in_reply_to, size, uid, msgno, recent, flagged, answered,
                deleted, seen, draft, and udate.
            */
            $overview = imap_fetch_overview($inbox, $email_number);
            $email_overview = &$overview[!0];

            /*********************************************************
            ********** HERE COMES THE REDBEAN ************************
            *********************************************************/
        }
    }

    /* to make sure the script was run */
    echo 'done';

    /* close the connection */
    imap_close($inbox);

?>

Step 3: Insert and Load using RedBeanPHP

To avoid copying all the above code all over again for every step, I will just provide the working code extracted from the place where it says "HERE COMES THE REDBEAN".

In this step we will demonstrate how to insert records into a table using RedBean, we will first create a bean (a new table record) and store only one attribute of an email message_id. But suffix _id is reserved by RedBeanPHP to handle relationships, we need to store it int messageID columns instead. Once the bean is created, we will try to load the saved record from the database based on the returned id property.

INSERT a record

To create a record we need to call R::dispense() function with a name of the bean, which will become the name of the table where this type of beans will be stored.

$bean = R::dispense('email');

To add columns to our email table, all you have to do is reference an attribute of the bean.

$bean->messageID = $email_overview->message_id;

When you store this record, it will save the value into a column called messageID.

At the end, store the bean.

$id = R::store($bean);

The first time you call store on this type of the bean, ReBean will check whether or not there exists a table called email. If not, it will create one with the columns set as attributes of the $bean object.

LOAD the record

To retrieve a record from a database, we need to call R::load() function passing the bean type name (the table name) as well as the id of the record.

$email = R::load('email', $id);

To confirm that the record has been successfully stored, let's output the messageID we've just stored.

echo $id . ' -> messageID: ' . htmlentities($email->messageID)
         . '<br /><br />';

The reason we used htmlentities() PHP function here is that the message_id in Gmail is wrapped in chevrons (<>) like <E1LgAU8-0007Y8-Pb@server.hosting24.com> which must be converted into true HTML character, or they will be interpreted by the browser as tags.

To glue everything up, here is the code:

/* insert an email bean with only a message_id */
$bean = R::dispense('email');
$bean->messageID = $email_overview->message_id;

/* save the bean */
$id = R::store($bean);

/* reload the bean */
$email = R::load('email', $id);

/* display the messageID */
echo $id . ' -> messageID: ' . htmlentities($email->messageID)
        . '<br /><br />';

This will generate the following table schema:

CREATE TABLE "email"(
      "id" integer AUTO_INCREMENT,
      "messageID" character varying(1073741823),
      CONSTRAINT pk_email_id PRIMARY KEY("id")
);

Step 4: Auto create columns and Find

Now we will see how RedBean automatically adjusts our database schema based on our code. We will add a second email attribute to the existing bean (subject). First, we need to find the existing bean.

$bean = R::findOne('email', ' messageID = :messageID', array(':messageID'=>$email_overview->message_id));

We use R::findOne() function because we are certain that there can be only one unique email with our message_id.

If we do not find such an email, we will create a new bean for it. As we have found our email, let's assign a new column to store the subject of the email.

$bean->subject = $email_overview->subject;

When we store this bean, it will alter our email table and add a new column called subject. See the below schema generated for our table. See how correct it is. Later we have a chance to manually adjust the schema if necessary, for example by setting the maximum length for messageID or subject.

CREATE TABLE "email"(
      "id" integer AUTO_INCREMENT,
      "messageID" character varying(1073741823),
      "subject" character varying(1073741823),
      CONSTRAINT pk_email_id PRIMARY KEY("id")
);

To confirm that everything has been stored correctly, we will load the bean again based on its id. Here is the code for this step.

/* check if an email with such message_id already exists */
$bean = R::findOne('email', ' messageID = :messageID', array(':messageID'=>$email_overview->message_id));

/* if not, create one */
if (!$bean)
{
      /* insert an email bean with only a message_id */
      $bean = R::dispense('email');
      $bean->messageID = $email_overview->message_id;
}

/* now assign the subject for this email bean */
$bean->subject = $email_overview->subject;

/* save the bean */
$id = R::store($bean);

/* reload the bean */
$email = R::load('email', $id);

/* display the messageID and the subject */
echo
      $id . ' -> messageID: ' . htmlentities($email->messageID)
      . '<br />subject: ' . $email->subject
      . '<br /><br />';

Step 5: Save Special Types

In RedBean Date, Datetime, and Spatial types are considered as special types. In this step we will add the date attribute of an email to the existing bean and see how RedBean handles this.

/* check if an email with such message_id already exists */
$bean = R::findOne('email', ' messageID = :messageID', array(':messageID'=>$email_overview->message_id));

/* if not, create one */
if (!$bean)
{
    /* insert an email bean with only a message_id */
    $bean = R::dispense('email');
    $bean->messageID = $email_overview->message_id;

    /* now assign the subject for this email bean */
    $bean->subject = $email_overview->subject;
}

/* now assign the date for this email bean */
$bean->date = date('Y-m-d H:i:s', $email_overview->udate);

/* save the bean */
$id = R::store($bean);

/* reload the bean */
$email = R::load('email', $id);

/* display the messageID, the subject, and the date */
echo
    $id . ' -> messageID: ' . htmlentities($email->messageID)
    . '<br />subject: ' . $email->subject
    . '<br />date: ' . $email->date
    . '<br /><br />';

After we store the date attribute, we've got the following schema. Notice that the date column has been stored as DATE type.

CREATE TABLE "email"(
      "id" integer AUTO_INCREMENT,
      "messageID" character varying(1073741823),
      "subject" character varying(1073741823),
      "date" date,
      CONSTRAINT pk_email_id PRIMARY KEY("id")
);

However, there is one limitation on this matter in RedBeanPHP. It recognizes so far only YYY-MM-DD format for DATE and YY-MM-DD HH:MM:SS format for DATETIME. If you enter dates in other format, eg. separated with a slash, the column will be stored as VARCHAR. I hope in the future, RedBean will support other formats as well, because in CUBRID, users can omit some parts in DATE and DATETIME data types.

Conclusion

As you can see, using RedBean as an ORM for your prototype development makes the work go much faster. You no longer have to prepare your database schema (how do you know what it will look like?). You focus on the actual application development. Once you are done developing and ready to go production, you may freeze RedBean which will no longer make any changes to the database schema. Very simple, very convenient!

In this tutorial I haven't covered many aspects of RedBeanPHP but I hope this tutorial will give you a good place to start. Below you can find the full code of the example we have created in this tutorial.

<?php
    /* first, we need to include redbean */
    require_once('rb.php');

    /* now connect to a CUBRID database */
    R::setup('cubrid:host=localhost;port=30000;dbname=imap_redbean', 'dba', '');

    /* connect to gmail */
    $hostname = '{imap.gmail.com:993/imap/ssl/novalidate-cert}INBOX';
    $username = 'mygmailusername';
    $password = 'mygmailpassword';

    /* try to connect */
    $inbox = imap_open($hostname, $username, $password) or die('Cannot connect to Gmail: ' . imap_last_error());

    /* grab ALL emails */
    $emails = imap_search($inbox, 'ALL');

    /* if emails are returned, cycle through each... */
    if($emails)
    {
        /* for every email... */
        foreach($emails as $email_number)
        {
            /*  get information specific to this email
                returns an array with the following properies:
                subject, from, to, date, message_id, references,
                in_reply_to, size, uid, msgno, recent, flagged, answered,
                deleted, seen, draft, and udate.
            */
            $overview = imap_fetch_overview($inbox, $email_number);
            $email_overview = &$overview[!0];

            /*********************************************************
            ********** HERE COMES THE REDBEAN ************************
            *********************************************************/

            /* check if an email with such messageID already exists */
            $bean = R::findOne('email', ' messageID = :messageID', array(':messageID'=>$email_overview->message_id));

            /* if not, create one */
            if (!$bean)
            {
                /* insert an email bean with only a messageID */
                $bean = R::dispense('email');
                $bean->messageID = $email_overview->message_id;

                /* now assign the subject for this email bean */
                $bean->subject = $email_overview->subject;
            }

            /* now assign the date for this email bean */
            $bean->date = date('Y-m-d H:i:s', $email_overview->udate);

            /* save the bean */
            $id = R::store($bean);

            /* reload the bean */
            $email = R::load('email', $id);

            /* display the messageID, the subject, and the date */
            echo
                $id . ' -> messageID: ' . htmlentities($email->messageID)
                . '<br />subject: ' . $email->subject
                . '<br />date: ' . $email->date
                . '<br /><br />';
        }
    }

    /* to make sure the script was run */
    echo 'done';

    /* close the connection */
    imap_close($inbox);

?>

Tadpole for DB Tools - SQL Client

2012-07-15T21:14:46-07:00

Tadpole for DB Tools is a very easy to use SQL Client written in Java (Eclipse RAP) which allows to execute queries in a Web browser. It is very useful for those users who deploy heterogeneous database servers and need to access them through a single unified interface. One of its key features is that it does not require any installation: simply extract and start the program.

[Tadpole Key Features]
[Tadpole SQL Client Tutorial] + Screenshots
Github Issue Tracker (bug reports, questions, discussions)

Tadpole for DB Tools is distributed under the terms of Eclipse Public License (EPL).

PhpStorm CUBRID Tutorial

2012-10-09T04:37:34-07:00

PhpStorm is a lightweight and smart PHP IDE focused on developer productivity that deeply understands your code, provides smart code completion, quick navigation and on-the-fly error checking. It is always ready to help you shape your code, run unit-tests or provide visual debugging.

In order to use PhpStorm with CUBRID all that is needed is to install the CUBRID PHP Driver according to your PHP version and operating system. All the installation instructions are available here: http://www.cubrid.org/wiki_apis/entry/cubrid-php-driver-installation-instructions

Check out examples of usage here: http://www.cubrid.org/blog/cubrid-appstools/best-php-ide-phpstorm-now-supports-cubrid-api-syntax/

If you have any questions, ask it on on our Q&A Site or post it on our forum.

PhpStorm Key Features

2012-10-09T04:34:10-07:00

PhpStorm offers the following features

Intelligent PHP Editor
- PHP 5.4 Language Features Support
- PHP code completion
- PHPDoc support
- Smart Duplicated Code Detector
- PHP Code Sniffer
- PHP refactoring
- Smarty templates editing
- Efficient project analysis and navigation
Smart Environment
- PHP UML
- Drupal & Symfony2 Coding Style Support
- Version control systems integration
- Local history
- Phing Support
PHPUnit, Debugger & Profiler
- PHPUnit
- Visual Debugger
- Profiler integration
Lightweight IDE
- Use the same environment on Windows, Mac OS and Linux
- Open code from anywhere and start working in no time
JavaScript & HTML/XHTML/CSS
- Includes all the features of WebStorm
- DOM-Based, browser-specific completion
- Code navigation and usages search
- ECMAScript Harmony Support
- JavaScript refactoring
- JavaScript debugger
- Validation and quick-fixes

PhpStorm - Lightweight and Smart PHP IDE

2012-10-09T04:29:24-07:00

[PhpStorm Key Features]
[PhpStorm CUBRID Tutorial]
PhpStorm Q&A
JIRA Issue Tracker

SOFA Statistics CUBRID Windows Tutorial

2012-10-09T03:35:37-07:00

Note: CUBRID will be integrated into SOFA Statistics 1.2.3 on Windows.

1. Download the sofastats-*.*.*_for_win.zip file from http://www.sofastatistics.com/downloads.php.

2. Install the executable file within the archive.

3. Download and Install CUBRID (with demodb) (http://www.cubrid.org/wiki_tutorials/entry/installing-cubrid-on-windows)

4. Download and Install CUBRID python driver (http://www.cubrid.org/wiki_apis/entry/downloading-and-installing-precompiled-cubrid-python-driver)

5. Run sofastats.exe

6. Select a new Project (Click the Select Project Button)

7. Click on "New" button

8. Type in the Project Settings: Project Name, select "CUBRID" as Default Database Engine, set the default database name, default table, host and username/password pair. demodb has no password by default.

9. Now, that everything is set up here is an example on how to create a report a table and its output:

If you encounter any problems or want to just see more examples, check out http://www.sofastatistics.com/help.php, ask a question on our Q&A site or post it on our forum.

SOFA Statistics CUBRID Ubuntu Tutorial

2012-10-09T03:25:40-07:00

1. Download the sofastats-*.*.*-1.deb file from http://www.sofastatistics.com/downloads.php.

2. Install the deb file using:

sudo dpkg -i sofastats-*.*.*-1.deb
sudo apt-get -f install

3. Install cubrid and cubrid-demodb on Ubuntu (http://www.cubrid.org/wiki_tutorials/entry/installing-cubrid-on-ubuntu)

4. Install python-cubriddb on Ubuntu (http://www.cubrid.org/wiki_apis/entry/installing-cubrid-python-driver-using-apt-get-ubuntu)

5. Open a terminal and run "sofastats".

6. Select a new Project (Click the Select Project Button)

7. Click on "New" button

8. Now, that everything is set up here is an example on how to create a report a table and its output:

If you encounter any problems or want to just see more examples, check out http://www.sofastatistics.com/help.php, ask a question on our Q&A site or post it on our forum.

SOFA Statistics CUBRID Tutorial

2012-10-03T04:24:51-07:00

CUBRID has been a part of SOFA Statistics since version 1.2.2 on Ubuntu and it will be starting with version 1.2.3 on Windows also. Check out the tutorials below:

[SOFA Statistics CUBRID Windows Tutorial]
[SOFA Statistics CUBRID Ubuntu Tutorial]

SOFA Statistics Key Features

2012-10-03T04:21:52-07:00

SOFA Statistics is an open-source statistical package, with an emphasis on ease of use, learn as you go, and beautiful output. The name stands for Statistics Open For All.

SOFA Statistics comes with the following features:

Ongoing Development
Beauty - Attractive Output
Database Friendly
Spreadsheet Friendly
Data Entry Friendly
Easy Data Recoding
Output You Can Share Easily
Main Tests and Measures Made Easy
Learn As You Go
Automated Reporting
Speaking your language (English, Croatian, Spanish, Russian, Galician and Breton)

For a complete list of features visit http://www.sofastatistics.com/features.php

SOFA Statistics

2012-10-03T04:16:08-07:00

SOFA Statistics is an open-source statistical package, with an emphasis on ease of use, learn as you go, and beautiful output. The name stands for Statistics Open For All. It has a graphical user interface and can connect directly to MySQL, PostgreSQL, SQLite, MS Access, Microsoft SQL Server, and CUBRID. Data can also be imported from CSV files or spreadsheets (Microsoft Excel, OpenOffice.org Calc, Gnumeric, Google Docs).

Installation packages are available for several Operating Systems such as Microsoft Windows, Ubuntu, ArchLinux, Linux Mint, and Mac OS X (Lion, Leopard and Snow Leopard).

SOFA Statistics is written in Python, and the widget toolkit used is wxPython. The statistical analyses are based on functions available through the Scipy stats module.

Analysis and reporting can be automated using Python scripts – either exported directly from SOFA Statistics or manually written.

[SOFA Statistics Key Features]
[SOFA Statistics CUBRID Tutorial]
SOFA Q&A
JIRA Issue Tracker

QDepo

2012-08-09T01:13:53-07:00

QDepo - A desktop application for retrieving and exporting data from relational database systems to spreadsheet files, formerly known as "TPDA - Query Repository Tool".

The supported output file formats are Excel (.xls), ODF and CSV. The full list of the supported database management systems includes: CUBRID, Firebird, MySQL, PostgreSQL and SQLite.

The graphical user interface is based on wxPerl and/or PerlTk GUI toolkit with the same functionality for both, with a few minor differences.

QDepo official website
Download
[QDepo Key Features]

[QDepo CUBRID Tutorial]
QDepo Q&A
JIRA Issue Tracker

QDepo using CUBRID - Tutorial

2012-08-09T01:20:54-07:00

1. Prerequisites

Perl and the required Perl modules. For Windows, the recommended Perl distributions are: Citrus Perl and Strawberry Perl. Both come with Wx and Tk toolkit modules preinstalled.

A working CUBRID server with the "demodb" database created and started. The example configuration is for a local installation, but any other host name can be used instead of "localhost". The IP address is an other valid option.

Note: the application can be installed and run on any OS where Perl and the required modules are available, but the author has tested it only on GNU/Linux and Microsoft Windows.

Note: QDepo is the new name of the "TPDA - Query Repository Tool" project.

2. Installation and Configuration

This is a Perl application, so the principle is pretty simple: download the package from sourceforge, unpack, install the prerequisites listed in Makefile.PL, then install it like any other standard Perl module:

% tar xvzf QDepo-0.XX.tar.gz
% cd QDepo-0.XX

The easiest way to install the prerequisites is with:

% cpan .

or

% cpanm --installdeps .     #  with App::cpanminus

Note: There is a space and a dot at the end of the commands.

The graphical user interface can use the PerlTk or wxPerl widget libraries. Install one of them or both. To switch between the two toolkits, set "widgetset" to "Tk" or "Wx", in the ".qdepo/etc/main.yml" configuration file.

This are some of the Perl module prerequisites, for the graphical user interface:

wxPerl:

Wx
Wx::Perl::ListCtrl

PerlTk:

Tk
Tk::MListbox
Tk::MsgBox
Tk::StatusBar
Tk::ToolBar

And of course, for the database we use the DBD::cubrid module. Add the prefix for CUBRID in DBI.pm (I have DBI v1.620), like this:

# --- Driver Specific Prefix Registry ---
my $dbd_prefix_registry = {
...
  cubrid_      => { class => 'DBD::cubrid',         },
...
};

Also, the test 40lobs_file.t must be ignored.

There are several modules that can be used for exporting:

Spreadsheet::WriteExcel
Text::CSV_XS
OpenOffice::OODoc
ODF::lpOD

It is recommended to use the Spreadsheet::WriteExcel module for generating Microsoft Excel compatible files and the Text::CSV_XS module for generating CSV files. The former is a decent alternative because it can be imported in spreadsheet applications and works on any platform. This two are also the fastest modules among the alternatives.

After installing the required modules, continue with the installation:

make
make test
make install

At first start, the configuration directory is initialized automatically. The following command will do that and also will list all the currently defined configurations in the terminal window.

qdepo -l

Next, we run the following command to create a new configuration. Multiple database connection configurations can coexists using any of the database interface modules supported by the application.

qdepo -i cubrid-test

This command will create a new configuration directory underneath the ".qdepo/db/" path. This directory contains two sub directories, "etc" and "qdf". The "etc" directory contains a file named "connection.yml". If your CUBRID server is not installed on localhost then change the connection parameters in this file as appropriate for your system.

The other directory named "qdf" is the place where your query definition files are stored. The ".qdf" files can be created and updated with the graphical user interface.

3. Adding a new Query

The application has, hopefully, a simple and intuitive interface. Start the graphical user interface with the following command:

qdepo cubrid-test

The first example shows how to add a very basic query, and the last example adds a parameter. Up to five parameters can be used currently.

The technology behind the implementation for the parameters, is simple and may seem naive (and maybe it is, but works pretty well with simple queries). Whenever the "valueN" string (where "N" can take values from 1 to 5) is found in the query text, it is replaced with a "?" character, a placeholder. Then the associated value from the Parameters tab is bound with each placeholder. "N" must occur in ascending numerical order in the query text. That is "value1" first, than "value2", and so, until "valueN".

3.1 The Simplest Query

Add a new query using the button from the toolbar. The application will automatically enter in edit mode. Change the title to "Athletes list", the output file name to "athletes_list" and the description to "List of all the athletes from the table".

Here is a screenshot of the wxPerl version of the user interface:

Also, edit the SQL statement text:

SELECT *
FROM athlete

Click on the button to save and exit the edit mode.

The edit mode can be toggled with the toolbar button, but the application doesn't check if there is unsaved data in the controls (fields), the user have to explicitly click on the button to save the changes.

Switch to the "Log info" tab and click on the toolbar button. Watch the messages, and if all is good, then a new file named "athletes_list.xls", filled with the appropriate data, should have been created in the output path.

3.2 Query With A Parameter

Switch back to the "Query List" tab and click on the button again. Fill in the values for the title, output file name and description to "Athletes list, filtered", "athletes_list_filtered" and "List of the athletes, filtered by nation code". This is only an example, of course, you can enter anything that makes sense to you and helps to easily identify the query you wish to execute.

The Parameters tab contains 5 pair of text controls, where the left column contains the description of the parameter - any short text label and the second column contains the value of the parameter - without any quotes.

In the Parameters Tab fill in a description and a value for a parameter, for example for the "athlete" table:

description: Nation code
value      : ROU

Delete all other labels and values on other rows.

Switch to the "SQL Query" tab and edit the statement, to add the WHERE clause:

SELECT *
FROM athlete
WHERE nation_code = value1
Note: the value1 string is without any quotes.

This shows another feature of the program, the parameter is replaced with it's value when leaving the "edit mode".

Again, save and click on the toolbar button. A new file, filled with the appropriate data, should have been created in the output path.

4. Deleting Queries

I suppose that it's not a big surprise that deleting queries from the list is made using the toolbar button. The list entry and the associated ".qdf" file is not immediately deleted, only marked and deleted when the application is closed. There is a safety feature, the ".qdf" file is not deleted, only renamed to ".qdf.bak", so it can be recovered.

5. Conclusion

This concludes the tutorial for QDepo. If you have any questions please post them on our Q&A site or on our forum.

Thank you for your time and have fun using the application!

QDepo Key Features

2012-08-09T01:17:26-07:00

QDepo - Query Repository Tool is an open source, desktop application for retrieving and exporting data from relational database systems to spreadsheet files.

Key Features:

Support for CUBRID, Firebird, PostgreSQL, MySQL, SQLite
Export formats: CSV, Excel, ODF
Support for wxPerl and PerlTk for the graphical user interface

QDepo Key Features

2012-09-05T00:30:37-07:00

QDepo is an open source desktop application written in Perl (wxPerl and PerlTk) that allows users to retrieve and export data from various relational DBMSs to spreadsheet files. It provides the following features:

SQL query repository management. The repository consists of a collection of XML files which can easily be moved or copied to other computers.
Exports to Excel (.xls), ODF, and CSV files.
Supports CUBRID, Firebird, MySQL, PostgreSQL, and SQLite databases.

Tadpole SQL Client Tutorial

2012-07-16T03:32:07-07:00

In this tutorial we are going to show how to get started with this awesome Tadpole SQL Client. You can run Tadpole on any Web browser. If you cannot for some reason, file a bug report to Tadpole Github Issue Tracker. The developer is very responsive. I am sure he will resolve issues pretty quickly. So, let's get started.

Installation

First, download Tadpole. It is available for Windows, Linux and Mac OS X. Once downloaded, simply extract the contents of the archive. No further installation is required. Now double click on tadpole-standalone executable file to start it.

When the program is launched, it will automatically open your default Web browser and navigate to http://127.0.0.1:10081/db?startup=tadpole address. Sometimes the Web page opens faster before Tadpole is ready to listed to browser requests. This may lead to a 404 Page Not Found browser error. All you need to do is refresh the page. It should work now.

Login

When you navigate to http://127.0.0.1:10081/db?startup=tadpole you will be prompted to enter your login credentials. Since you do not have one at this point, you can either create New or login without credentials as a Guest or Manager user. Let's go and click on Manager button.

Once you are in the system, you will see a full-screen Dashboard consisting of 4 parts:

Main Toolbar at the top.
Connection Manager at the top left.
Object Explorer below Connection Manager.
Query Editor Window which occupies the most space.
And at the bottom the Status Bar.

Database Connection

To connect to your desired database, right click on a target Database Group (in this case we will connect to a CUBRID database), hover over Connection Manager then choose Connect Database menu item.

You will see the following DB Connect Dialog window where you need to enter your database connection info. In this tutorial we will connect to a remote CUBRID demodb database. Locale field is intentionally left blank as no value is required for CUBRID. Do not forget to enter the Display Name so that later you can distinguish the connections among many in the Connection Manager panel. If you want to access this database later, check the Save Database checkbox.

To test if your connection credentials are correct, press the Ping Test button. If everything is correct, you should see the success message as shown below. Once ready, press the OK button.

Once the database connection is successfully created, a connection record will be created under CUBRID group in Connection Manager panel.

Object Explorer

When you select a connection (single click; a double click will open the Query Editor), a list of tables will be displayed in the Object Explorer panel on the bottom left. There if you select a table, its column information will be displayed below as in the following figure.

You can similarly view all indexes, views, procedures, functions as well as triggers.

If you right click on the table list a context menu will popup as shown below.

If you choose any of the available menu items, an appropriate SQL statement will be generated and placed automatically into the main Query Editor. For example, if we click on Create Table menu item, the following SQL template will be placed which we can change according to our needs.

Likewise, if you click on Generate SQL Statement: Select the following will be displayed.

Query Editor

Execute SQL

To execute SQL you simply click on one of the two buttons: Execute or Execute ALL. The difference is that the first one will execute only the last SQL statement and display its output, while the second one will execute all SQL statements and display the output of the last statement.

Execute Plan for CUBRID, at the moment of writing this tutorial, is not supported in Tadpole. A feature request has been registered.

Format SQL

One nice feature of Tadpole allows users to quickly format the entered SQL. For example, the above generated CREATE TABLE statement can be transformed into the following when clicked on Format SQL button which is located in the Query Editor toolbar. Very nice feature especially if the editor contains many queries.

SQL to Application

This feature is also very convenient and unique to Tadpole. If you click on it while there is a SQL statement in the Editor, Tadpole will display a Java or PHP variable which will hold the same query as its value. You can simply copy and paste the provided code into your Java or PHP application.

ER Diagram

All Table ERD

Tadpole provides a very nice Entity-Relationship Diagram for any of connected databases. To generate the ER Diagram, right click on a database connection, hover over Connection Manager, then choose All Table ERD menu item.

This will generate ER Diagram like the one shown below.

Actually this one has also undergone the "Tree Auto Layout" process. When Tadpole generates ERD for your database, the tables in the diagram may look scattered throughout the canvas. To organize all the tables in one click as shown in the above figure, right click on any place of the canvas then choose Tree Auto Layout menu item from the displayed context menu.

Create ERD Diagram

Alternatively, if you do not want all tables be present in your diagram, you can create a new clean diagram and drag and drop necessary tables from Object Explorer. For this to work, instead of All Table ERD menu item choose Create ERD Diagram menu item from Connection Manager menu. A blank diagram canvas will open and you can start dragging tables from Object Explorer. At some point do not forget to save your work. You can find the Save button in the form of a floppy disk in the main toolbar at the top. Next time you start tadpole, the saved ERD diagrams will be there for you under the connection it belongs to in the Connection Manager.

What's next

Since Tadpole is still in its early development stage, there are many great features we can expect in coming versions. The developer has told that he is working on the following items:

Database Monitoring
Database Migration from one DB Server to another
Test Data Generation
PostgreSQL, DB2 and Cassandra support
Improved basic functionality
NoSQL modeling tool

When new version arrives, we will write more tutorials. So bookmark this page if you passionately wait for new features from Tadpole.

GestDB CUBRID Tutorial

2012-09-04T03:51:44-07:00

GestDB is a client to access relational databases. It can be used to access a large array of databases including CUBRID.

Step 1: Download GestDB

GestDB can be downloaded from https://sourceforge.net/projects/gestdb/files/gestdb.

In order to run it, you need to install the Java JRE or JDK 1.6 or above. You can find the downloads page at http://www.oracle.com/technetwork/java/javase/downloads/index.html.

The tutorial on how to install and configure CUBRID is found at http://www.cubrid.org/wiki_tutorials/entry/cubrid-installation-instructions.

You have to unzip the ZIP file to a directory, eg "/ home / myuser / gestdb /" or "c: \ Users \ myuser \ Desktop \ gestdb".

Step 2: Install JDBC driver

You need the JDBC driver to connect to the database. A version of the program that includes the driver for CUBRID.
If you have a version without the driver, we downloaded the driver from the manufacturer and copy it in the subdirectory "lib", to start the application will load automátimanete.
There is another way to put the JDBC driver. Using the configuration window by clicking the Add button driver.
The application allows you to have all the drivers needed.

Step 3: Configure conection

We are ready to use the application. The run with the command "run.cmd" or "run.sh" if you're on Windows or UNIX respectively.

Press the first button we have in the top left to create a new connection.

Press "Create" button.

Fill in the fields with your data connection. In this example we will connect to the database that brings Cubrid demodb.

Press the "Test connection" to test the connection.

If you have errors appears a window similar to the following.

If all goes well, appears it a window like the one below.

Click on the "Create connection".

Step 4: Connect to the database

Select your connection and press "Connect" or double click.

We already have a good connection to our database, the next step is to test it.

We can launch a query to pull data from an existing table using the syntax "select * from {table}" and pressing the "run" that have as gears, or selecting a table in the combobox and pressing the button with a "gear".

Below I will show a way to try creating a table, inserting a record and then launching a consultation on table.

GestDB allows multiple querys in the editor and launch only the selected query, this is method we to use it.

JMyETL - Data Import/Export Tool

2012-08-03T02:25:27-07:00

JMyETL is a very useful Java based application that allows import/export operations on many database systems. The databases supported are CUBRID, FrontDB, Sybase ASE/ASA, Oracle, MySQL, PostgreSQL, DB2, SQLServer, Access and SQLite.

[JMyETL Key Features]
[JMyETL CUBRID Tutorial]
JMyETL Q&A
JIRA Issue Tracker

Brig - C++ header-only libraries

2012-07-03T01:20:02-07:00

Brig is a collection of cross-platform C++ header-only libraries that can be used for rapid application development for databases.

[brig key features]
[brig CUBRID tutorial]
brig Q&A
JIRA Issue Tracker

JMyETL CUBRID Tutorial

2012-08-03T02:38:29-07:00

The installation of JMyETL is fairly easy. You just need to follow a few simple steps.

First, download JMyETL and extract it. In the extracted folder, find jmyetl.ini configuration file and edit it to adjust the value of vm.location to your {JAVA_HOME}\jre\bin\server\jvm.dll.

Make sure that the path correctly points to a jvm.dll file from a Java 32 bit version otherwise you will keep getting a "Error starting Java VM." error. Usually the 32 bit version is located in C:\Program Files (x86)\ directory. If you already have a 64 bit version of JDK, you will also need to download the 32 bit version. The recommended JDK version is 1.6 or above.

The final confirmation file will look something like:

main.class=com.sql9.jmetl.MainFrame
classpath.1=*.jar;.
splash.image=SplashScreen.bmp
vm.location=c:\Program Files (x86)\Java\jdk1.7.0_07\jre\bin\server\jvm.dll
vmarg.1=-Xms64M
vmarg.2=-Xmx512M

Optionally, in jmyetl.ini configuration file you can also set the memory limitation for Java Virtual Machine (JVM). The default values are:

vmarg.1=-Xms64M
vmarg.2=-Xmx512M

Now open JmyETL.exe program. The following window will show up.

Choose SourceDB and Targetdb from the dropdown list.

For both fill out the {host}, {database}, {port} values and enter user and password information in the next two text fields. For example, CUBRID database connection URL should look like jdbc:cubrid:localhost:33000:demodb::: and user is dba with an empty password. MySQL connection URL should look like jdbc:mysql://localhost:3306/hibernate.

When connecting to a CUBRID database, make sure it has been started. For Access Database, you don't need to create the mdb file in advance. If it doesn't exist, JMyETL will create it for you.

Then click the Test Connect buttons to ensure both connection URLs are correct. If the connection has been successfully established, first, you will notice that Test Connect button becomes green. Second, on the left panel you will see a list of tables from the source database.

Now select all or some of tables which you would like to export from SourceDB to TargetDB. Once ready, click the Start Import button. Done! This will automatically create corresponding tables in the TargetDB and import all records from SourceDB.

GestDB - Easy Access To Relational Databases

2012-09-04T03:30:59-07:00

GestDB is a client to access relational databases.

This client is developed in Java and therefore it is cross-platform, meaning it works on many operating systems. To use it we need to have installed a java virtual machine JRE or JDK 1.6 or above.

One of the biggest advantages of this program is the size, 8 MB program and 12.5 MB with free JDBC drivers; MYSQL, H2, jtds, HyperSQL, CUBRID, and Ingres.

Some of the managers that can be connected are as follows; Oracle, DB2, SQLServer, Informix, MYSQL, Firebird, ODBC, Cloudscape, Cloudscape RMI, CUBRID, DaffodilDB Embedded, DaffodilDB Server, db2 CAE, db2 Universal, Derby embedded, Derby embedded memory, Derby server, firstsql, FrontBase, H2 Embedded, H2 Server, Hypersonic SQL v1.3, HyperSQL embedded, HyperSQL server, Ingres, InstantDB v3.14, Interbase, InterSystems Cache, JTDS Sqlserver, JTDS Sybase, Mimer, oracle oci 8i, oracle oci 9i, Pervasive, PointBase Server, PointBase Embedded, PointBase Micro, postgresql 7.0, Sap MaxDB, Sybase 5.2, etc.

[GestDB Key Features]
[GestDB CUBRID Tutorial]
GestDB Q&A
JIRA Issue Tracker

GestDB Key Features

2012-09-04T03:46:29-07:00

GestDB is a client to access relational databases. Some of the most important features are:

Possibility to connect to both databases vary but are of different types.
Visualization of data Structures characteristics.
Query assistant.
Data export from one database type to another (example: Oracle to DB2). Database structure exporting its also allowed (create table, index, etc....).
Data export in plain format.
Data import from plain text archives and SQL scripts, from independant files or complete directories.
SQL commands History.
Automatic Opening of the opened connections on the last session.
Occupation statistics.
Multiple Tabs for SQL commands in every session.
Multiplatform running.
Java compatible (+JRE 1.6).
Graphical or text mode.
Unattended data backups (batch processes).
Source Code generator for JAVA, HTML, XML, VB, ASP, PHP.
Code formatter.
Allows you to generate a graph from the results of a query.
Filter the data retrieved.
Search.
Favorite SQL Query Management.
Viewing the metadata structure of a query.
Limit the number of records returned in a query.
Modifying data directly in the results table.

JMyETL Key Features

2012-08-03T02:29:15-07:00

JMyETL is a very useful Java based application that allows import/export operations on many database systems. It supports the following export operations for each database type:

MySQL --> Sybase ASE/ASA, Oracle, Access, PostgreSQL, SQL Server, DB2, SQLite, CUBRID
Sybase ASE --> Sybase ASA, MySQL, Oracle, Access, PostgreSQL, SQL Server, DB2, SQLite, CUBRID
Sybase ASA --> Sybase ASE, MySQL, Oracle, Access, PostgreSQL, SQL Server, DB2, SQLite, CUBRID
Oracle --> Sybase ASA, Sybase ASE, MySQL, Access, PostgreSQL, SQL Server, DB2, SQLite, CUBRID
Access --> Sybase ASE, Sybase ASA, MySQL, Oracle, PostgreSQL, SQL Server, DB2, SQLite, CUBRID
PostgreSQL --> Sybase ASE, Sybase ASA, MySQL, Oracle, Access, SQL Server, DB2, SQLite, CUBRID
SQL Server --> Sybase ASE, Sybase ASA, MySQL, Oracle, PostgreSQL, Access, DB2, SQLite, CUBRID
DB2 --> Sybase ASE, Sybase ASA, MySQL, Oracle, PostgreSQL, SQL Server, Access, SQLite, CUBRID
SQLite --> Sybase ASE, Sybase ASA, MySQL, Oracle, PostgreSQL, SQL Server, DB2, Access, CUBRID
CUBRID --> Sybase ASE, Sybase ASA, MySQL, Oracle, PostgreSQL, SQL Server, DB2, Access, SQLite