Pages

Monday, December 17, 2012

SQLite3: An Overview with Code Snippets in C and Python.

SQLite Introduction

SQLite is a light Database library written in C. You can use this library for database operations instead of using a DBMS process running. If your application needs a database but the operations of it are so simple and the access flow is not so high, it's recommended that you use this database approach. The current version of SQLite is 3.x.

In this post we will introduce some basics functions of the library and they will be showed in two programming language: C and Python. The intention is show you how easily the SQLite is.

The database schema used is the example below.





This is a Company schema and it has your employees, the dependets of the employees and some management of Company's projects.

We going to create the Database tables and do some basic operations. First, we create the tables, your primary keys and foreing keys. You can create a function to do it.

Here we create a function called

C:
int create_database_tables(sqlite3 *handle)

In Python, the constructor __init__ of the class create the tables

Obviously, don't forget to include the libraries

C:
#include <sqlite3.h>

Python:
import sqlite3

You have to pass the sqlite3 handle as an argument to execute the statements. Each SQL statemens was defined in string constant variables. After the statements will be executed. The body of the function can be viewed below.

C:
int create_database_tables(sqlite3 *handle) {
 
    /** ERROR message. **/   
    char *errmsg;

    /** String who create the table 'employee'. **/     
    const char * employee = "CREATE TABLE IF NOT EXISTS employee \
                             (cpf_emp TEXT PRIMARY KEY, \
                             name TEXT NOT NULL, code TEXT, \
dpt_acro TEXT, begin_date TEXT, \
FOREIGN KEY(code) REFERENCES employee(cpf_emp), \
FOREIGN KEY(dpt_acro) \
                             REFERENCES departament(acro_dept))";

    /** String who create the table 'relative'. **/
    const char * relative = "CREATE TABLE IF NOT EXISTS relative \
                             (cpf_emp TEXT, name TEXT, \
                             gender TEXT, PRIMARY KEY (cpf_emp, name), \
                             FOREIGN KEY(cpf_emp) \
                             REFERENCES employee(cpf_emp))";
 
    /** String who create the table 'department'. **/   
    const char * department = "CREATE TABLE IF NOT EXISTS department \
                               (acro_dpt TEXT PRIMARY KEY, \
                               name_dpt TEXT NOT NULL, \
                               cpf_emp TEXT NOT NULL, \
                               FOREIGN KEY(cpf_emp) \
                               REFERENCES employee(cpf_emp))";

    /** String who create the table 'project'. **/   
    const char * project = "CREATE TABLE IF NOT EXISTS project \
                            (number_project INTEGER PRIMARY KEY, \
                            name_project TEXT NOT NULL)";
 
    /** String who create the table 'control'. **/   
    const char * control = "CREATE TABLE IF NOT EXISTS control \
                            (acro_dpt TEXT, number_project TEXT, \
                            PRIMARY KEY(acro_dpt, number_project), \
                            FOREIGN KEY(acro_dpt) \
                            REFERENCES department(acro_dept), \
                            FOREIGN KEY(number_project) \
                            REFERENCES project(number_project))";
 
    /** String who create the table 'develop'. **/   
    const char * develop = "CREATE TABLE IF NOT EXISTS develop \
                            (cpf_emp TEXT, number_project TEXT, \
                            time_worked FLOAT, \
                            PRIMARY KEY(cpf_emp, number_project), \
                            FOREIGN KEY(cpf_emp) \
                            REFERENCES employee(cpf_emp), \
                            FOREIGN KEY(number_project) \
                            REFERENCES project(number_project))";
 
    /** Execute all the SQL create tables statements. **/   
    if(sqlite3_exec(handle,employee,0,0,&errmsg) != SQLITE_OK) {
        printf("ERROR: %s\n", errmsg);
        return -1;
    }
     
    if(sqlite3_exec(handle,relative,0,0,&errmsg) != SQLITE_OK) {
        printf("ERROR: %s\n", errmsg);
        return -1;
    }
 
    if(sqlite3_exec(handle,department,0,0,&errmsg) != SQLITE_OK) {
        printf("ERROR: %s\n", errmsg);
        return -1;
    }
 
    if(sqlite3_exec(handle,project,0,0,&errmsg) != SQLITE_OK) {
        printf("ERROR: %s\n", errmsg);
        return -1;
    }
     
    if(sqlite3_exec(handle,control,0,0,&errmsg) != SQLITE_OK) {
        printf("ERROR: %s\n", errmsg);
        return -1;
    }
     
    if(sqlite3_exec(handle,develop,0,0,&errmsg) != SQLITE_OK) {
        printf("ERROR: %s\n", errmsg);
        return -1;
    }
     
    return 1;
}


Python:
class Database:
 
    def __init__(self, cur):

        # String who create the table 'employee'.
        employee = 'CREATE TABLE IF NOT EXISTS employee \
                    (cpf_emp TEXT PRIMARY KEY, \
                    name TEXT NOT NULL, code TEXT, \
dpt_acro TEXT, begin_date TEXT, \
FOREIGN KEY(code) REFERENCES employee(cpf_emp), \
FOREIGN KEY(dpt_acro) \
                    REFERENCES departament(acro_dept))'

        # String who create the table 'relative'.
        relative = 'CREATE TABLE IF NOT EXISTS relative \
                    (cpf_emp TEXT, name TEXT, \
                    gender TEXT, PRIMARY KEY (cpf_emp, name), \
                    FOREIGN KEY(cpf_emp) \
                    REFERENCES employee(cpf_emp))'

        # String who create the table 'department'.
        department = 'CREATE TABLE IF NOT EXISTS department \
                      (acro_dpt TEXT PRIMARY KEY, \
                      name_dpt TEXT NOT NULL, \
                      cpf_emp TEXT NOT NULL, \
                      FOREIGN KEY(cpf_emp) \
                      REFERENCES employee(cpf_emp))'

        # String who create the table 'project'.
        project = 'CREATE TABLE IF NOT EXISTS project \
                   (number_project INTEGER PRIMARY KEY, \
                   name_project TEXT NOT NULL)'
   
        # String who create the table 'control'.
        control = 'CREATE TABLE IF NOT EXISTS control \
                   (acro_dpt TEXT, number_project TEXT, \
                   PRIMARY KEY(acro_dpt, number_project), \
                   FOREIGN KEY(acro_dpt) \
                   REFERENCES department(acro_dept), \
                   FOREIGN KEY(number_project) \
                   REFERENCES project(number_project))'
   
        # String who create the table 'develop'.
        develop = 'CREATE TABLE IF NOT EXISTS develop \
                   (cpf_emp TEXT, number_project TEXT, \
                   time_worked FLOAT, \
                   PRIMARY KEY(cpf_emp, number_project), \
                   FOREIGN KEY(cpf_emp) \
                   REFERENCES employee(cpf_emp), \
                   FOREIGN KEY(number_project) \
                   REFERENCES project(number_project))'
     
        try:          
            # Execute all the SQL create tables statements.
            cur.execute(employee)
            cur.execute(relative)
            cur.execute(departament)
            cur.execute(project)
            cur.execute(control)
            cur.execute(develop)
         
        except sqlite3.Error, e:
            # Throw an error if it occurs.
            print 'ERROR: ' % e.args[0]


The char pointer errmsg in C shows an error string if the SQL statement doesn't execute properly. However, in Python, we use try and except to catch an error of the SQL statement execution.

Before populate the tables, let's going to see the main() fucntion. There, we can verify how the database was initiated. The code is so simple.

C:
int main(int argc, char *args[]) {
 
    sqlite3_stmt * stmt;
 
    sqlite3 * handle;
 
    /** Open connection with the database. **/
    /** If the file does not exists, create it. **/
    if (sqlite3_open("sample.db",&handle)) {
      printf("Connection falied!\n");
      return -1;
    }

    /** Create the tables of our database. **/
    create_database_tables(handle);

    /** Populate the tables with data. **/ 
    insert_data_to_database(handle);
 
    /** Execute two queries: **/
    /**    A normal SELECT and a SELECT with INNER JOIN. **/
    select_data_of_database(handle, stmt);
    select_inner_join_data_of_database(handle, stmt);
 
    /** Create a Trigger that verifies alterations **/
    /** at the name column of the project's table. **/
    log_trigger_database(handle, stmt);
 
    /** Close connection. **/
    sqlite3_close(handle);
 
    return 0;
}

Python:
if __name__ == "__main__":
 
    con = None
 
    try:

        # Open connection with the database.
        # If the file does not exists, create it.

        con = sqlite3.connect('sample.db')

        # Get the cursor of connection.   
        cur = con.cursor()
     
        # Init the database with the constructor.
        db = Database(cur)
     
        con.commit()

        # Insert data into the tables.
        db.insert_data_into_database(cur)

        # Commit the modifications.   
        con.commit()

        # Execute the samples of SELECT.   
        db.select_data_of_database(cur)   
        db.select_inner_join_data_of_database(cur)
     
        # Create the Trigger example.
        db.log_trigger_database(cur)
     
    except sqlite3.Error, e:
        # Throw an error if it occurs.
        print "Error %s:" % e.args[0]
     
        sys.exit(1)
     
    finally:
        # Close the connection
        if con:
            con.close()


You can easily see the functions being called. In main() we simply execute the sample functions. In Python, if we don't commit the modifications, the next functions doesn't work. If we create the tables and, after, insert the data, the SELECT doesn't return values.

The next step is populate the tables with data. You can easily do it executing the strings with INSERT statements. The code seems like the create tables function. But, instead of strings with "CREATE TABLE..." we can use "INSERT..." and any other SQL word like "COMMIT", "ROLLBACK", "SELECT...", etc.

C:
int insert_data_into_database(sqlite3 *handle) {

    /** ERROR message. **/    
    char *errmsg;

    /** Insert data into 'employee'. **/    
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('123456789','John Smith','333445555','5','09-JAN-55')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('333445555','Franklin Wong','888665555','5','08-DEZ-45')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('999887777','Alicia Zelaya','987654321','4','19-JUL-58')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('987654321','Jeniffer Wallace','888665555','4','20-JUN-31')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('666884444','Ramesh Narayan','333445555','5','15-SET-52')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('453453453','Joyce English','333445555','5','31-JUL-62')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('987987987','Ahmad Jabbar','987654321','4','29-MAR-59')",
                  0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO employee VALUES \
                 ('888665555','James Borg',null,'1','10-NOV-27')",
                  0,0,&errmsg);

    /** Insert data into 'relative'. **/     
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('333445555','Alice','F')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('333445555','Theodore','M')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('333445555','Joy','F')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('987654321','Abner','M')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('123456789','Michael','M')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('123456789','Alice','F')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO relative VALUES ('123456789','Elizabeth','F')",
                 0,0,&errmsg);

    /** Insert data into 'department'. **/
    sqlite3_exec(handle,"INSERT INTO departament VALUES \
                 ('res','Research','333445555')",0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO departament VALUES  \
                 ('adm','Administration','987654321')",0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO departament VALUES  \
                 ('man','Management','888665555')",0,0,&errmsg);

    /** Insert data into 'project'. **/     
    sqlite3_exec(handle,"INSERT INTO project VALUES ('1','Product X')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO project VALUES ('2','Product Y')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO project VALUES ('3','Product Z')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO project VALUES ('10','Automation')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO project VALUES ('20','Reorganization')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO project VALUES ('30','Optimization')",
                 0,0,&errmsg);

    /** Insert data into 'control'. **/      
    sqlite3_exec(handle,"INSERT INTO control VALUES ('res','Product X')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO control VALUES ('res','Product Y')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO control VALUES ('res','Product Z')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO control VALUES ('man','Automation')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO control VALUES ('adm','Reorganization')",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO control VALUES ('adm','Optimization')",
                 0,0,&errmsg);
 
    /** Insert data into 'develop'. **/
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('123456789','1',32.5)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('123456789','2',7.5)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('666884444','3',40.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('453453453','1',20.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('453453453','2',20.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('333445555','2',10.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('333445555','3',10.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('333445555','10',10.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('333445555','20',10.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('999887777','30',30.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('999887777','10',10.0)",
                 0,0,&errmsg);
    sqlite3_exec(handle,"INSERT INTO develop VALUES ('987987987','10',35.0)",
                 0,0,&errmsg);
}

Python:
    def insert_data_into_database(self, cur):
     
        try:          
            # Insert data into 'employee'.
            cur.execute("INSERT INTO employee VALUES \
                     ('123456789','John Smith','333445555','5','09-JAN-55')")
            cur.execute("INSERT INTO employee VALUES \
                     ('333445555','Franklin Wong','888665555','5','08-DEZ-45')")
            cur.execute("INSERT INTO employee VALUES \
                     ('999887777','Alicia Zelaya','987654321','4','19-JUL-58')")
            cur.execute("INSERT INTO employee VALUES \
                     ('987654321','Jeniffer Wallace','888665555','4','20-JUN-31')")
            cur.execute("INSERT INTO employee VALUES \
                     ('666884444','Ramesh Narayan','333445555','5','15-SET-52')")
            cur.execute("INSERT INTO employee VALUES \
                     ('453453453','Joyce English','333445555','5','31-JUL-62')")
            cur.execute("INSERT INTO employee VALUES \
                     ('987987987','Ahmad Jabbar','987654321','4','29-MAR-59')")
            cur.execute("INSERT INTO employee VALUES \
                     ('888665555','James Borg',null,'1','10-NOV-27')")

            # Insert data into 'relative'.  
            cur.execute("INSERT INTO relative VALUES \
                        ('333445555','Alice','F')")
            cur.execute("INSERT INTO relative VALUES \
                        ('333445555','Theodore','M')")
            cur.execute("INSERT INTO relative VALUES \
                        ('333445555','Joy','F')")
            cur.execute("INSERT INTO relative VALUES \
                        ('987654321','Abner','M')")
            cur.execute("INSERT INTO relative VALUES \
                        ('123456789','Michael','M')")
            cur.execute("INSERT INTO relative VALUES \
                        ('123456789','Alice','F')")
            cur.execute("INSERT INTO relative VALUES \
                        ('123456789','Elizabeth','F')")

            # Insert data into 'department'.
            cur.execute("INSERT INTO departament VALUES \
                        ('res','Research','333445555')")
            cur.execute("INSERT INTO departament VALUES \
                        ('adm','Administration','987654321')")
            cur.execute("INSERT INTO departament VALUES \
                        ('man','Management','888665555')")

            # Insert data into 'project'.   
            cur.execute("INSERT INTO project VALUES ('1','Product X')")
            cur.execute("INSERT INTO project VALUES ('2','Product Y')")
            cur.execute("INSERT INTO project VALUES ('3','Product Z')")
            cur.execute("INSERT INTO project VALUES ('10','Automation')")
            cur.execute("INSERT INTO project VALUES ('20','Reorganization')")
            cur.execute("INSERT INTO project VALUES ('30','Optimization')")
 
            # Insert data into 'control'.
            cur.execute("INSERT INTO control VALUES ('res','Product X')")
            cur.execute("INSERT INTO control VALUES ('res','Product Y')")
            cur.execute("INSERT INTO control VALUES ('res','Product Z')")
            cur.execute("INSERT INTO control VALUES ('man','Automation')")
            cur.execute("INSERT INTO control VALUES ('adm','Reorganization')")
            cur.execute("INSERT INTO control VALUES ('adm','Optimization')")

            # Insert data into 'develop'.   
            cur.execute("INSERT INTO develop VALUES ('123456789','1',32.5)")
            cur.execute("INSERT INTO develop VALUES ('123456789','2',7.5)")
            cur.execute("INSERT INTO develop VALUES ('666884444','3',40.0)")
            cur.execute("INSERT INTO develop VALUES ('453453453','1',20.0)")
            cur.execute("INSERT INTO develop VALUES ('453453453','2',20.0)")
            cur.execute("INSERT INTO develop VALUES ('333445555','2',10.0)")
            cur.execute("INSERT INTO develop VALUES ('333445555','3',10.0)")
            cur.execute("INSERT INTO develop VALUES ('333445555','10',10.0)")
            cur.execute("INSERT INTO develop VALUES ('333445555','20',10.0)")
            cur.execute("INSERT INTO develop VALUES ('999887777','30',30.0)")
            cur.execute("INSERT INTO develop VALUES ('999887777','10',10.0)")
            cur.execute("INSERT INTO develop VALUES ('987987987','10',35.0)")
         
        except sqlite3.Error, e:
            # Throw an error if it occurs.
            print 'ERROR: ' % e.args[0]

Now, let's see two examples of SELECT statement.

The first function contains the simple SELECT.

C:
int select_data_of_database(sqlite3 * handle, sqlite3_stmt * stmt) {

    const char * tail;

    /** String with SELECT statement. **/
    const char * select_emp = "SELECT * FROM employee";
 
    /** Execute the SQL statement. **/
    if(sqlite3_prepare_v2(handle,select_emp,-1,&stmt,&tail) != SQLITE_OK) {
        printf("ERROR: Select wasn't executed!");
      return -1;
    }

    /** Output of the execution. **/
    printf("%s\n", select_emp);
    printf("==========================================================\n");
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        printf("%s | ", sqlite3_column_text(stmt, 0));
        printf("%s | ", sqlite3_column_text(stmt, 1));
        printf("%s | ", sqlite3_column_text(stmt, 2));
        printf("%s | ", sqlite3_column_text(stmt, 3));
        printf("%s\n", sqlite3_column_text(stmt, 4));
    }
    printf("==========================================================\n\n");

    /** Finish the statement. **/  
    sqlite3_finalize(stmt);
 
    return 1;
}

Python:
    def select_data_of_database(self, cur):
     
        try:
            # Execute the SQL statement.
            cur.execute("SELECT * FROM employee")

            # Output of the execution.
            print "SELECT * FROM employee"
            print "=========================================================="
            for row in cur:
                print row[0], '|', row[1], '|', row[2], '|', row[3], '|', row[4]
            print "==========================================================\n"
     
        except sqlite3.Error, e:
            print 'ERROR: ' % e.args[0]


The sqlite3_prepare_v2() function prepare the output of the SQL execution to be accessed with a pointer. On the other hand, the output data can accessed in sequence with the sqlite3_step() function. The columns can be accessed with the sqlite3_column_text() function, passing the statement pointer and the index of the column.

The other example function shows a INNER JOIN statement.

C:
int select_inner_join_data_of_database(sqlite3 * handle, sqlite3_stmt * stmt) {

    const char * tail;

    /** String with SELECT statement. **/
    const char * select_emp_and_rel = "SELECT * FROM employee \
                                       AS C JOIN relative \
                                       AS R ON C.cpf_emp=R.cpf_emp;";

    /** Execute the SQL statement. **/ 
    if(sqlite3_prepare_v2(handle,select_emp_and_rel,-1,&stmt,&tail) != SQLITE_OK) {
        printf("ERROR: Select wasn't executed!");
      return -1;
    }
 
    /** Output of the execution. **/
    printf("%s\n", select_emp_and_rel);
    printf("==========================================================\n");
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        printf("%s | ", sqlite3_column_text(stmt, 0));
        printf("%s | ", sqlite3_column_text(stmt, 1));
        printf("%s | ", sqlite3_column_text(stmt, 2));
        printf("%s | ", sqlite3_column_text(stmt, 3));
        printf("%s | ", sqlite3_column_text(stmt, 4));
        printf("%s | ", sqlite3_column_text(stmt, 5));
        printf("%s | ", sqlite3_column_text(stmt, 6));
        printf("%s\n", sqlite3_column_text(stmt, 7));
    }
    printf("==========================================================\n\n");

    /** Finish the statement. **/   
    sqlite3_finalize(stmt);
 
    return 1;
}

Python:
    def select_inner_join_data_of_database(self, cur):
     
        try:
            # Execute the SQL statement.
            cur.execute("SELECT * FROM employee AS C JOIN \
                         relative AS R ON C.cpf_emp=R.cpf_emp")
         
            # Output of the execution.
            print "SELECT * FROM employee AS C JOIN \
                   relative AS R ON C.cpf_emp=R.cpf_emp"
            print "=========================================================="
            for row in cur:
                print row[0], '|', row[1], '|', row[2], '|', row[3], '|',
                      row[4], '|', row[5], '|', row[6], '|', row[7]
            print "==========================================================\n"
     
        except sqlite3.Error, e:
            # Throw an error if it occurs.
            print 'ERROR: ' % e.args[0]


The process is exactly the same, but observe the difference between strings.

Finally, the sample has a function who creates a trigger. The trigger records changes in project's names in a table called "log"and, when it happens, the time and date is recorded too.

C:
int log_trigger_database(sqlite3 * handle, sqlite3_stmt * stmt) {

    /** String who create the 'log' table used by trigger. **/
    const char * log = "CREATE TABLE log(id integer PRIMARY KEY, \
                        project_old_name TEXT, \
                        project_new_name TEXT, date TEXT)";

    /** String who create the trigger. **/
    const char * trigger = "CREATE TRIGGER project_trigger \
                            UPDATE OF name_project ON project \
                            BEGIN INSERT INTO Log(project_old_name, \
                            project_new_name, date) \
                            VALUES(old.name_project, new.name_project, \
                            datetime('now')); END;";

    /** UPDATE statement to verify the trigger. **/
    const char * update_trigger = "UPDATE project SET name_project='Product W' \
                                   WHERE number_project='3'";

    /** String with SELECT statement. **/
    const char * select_log = "SELECT * FROM log";
 
    const char * tail;
 
    char *errmsg;
 
    /** Execute all the SQL statement. **/ 
    if(sqlite3_exec(handle,log,0,0,&errmsg) != SQLITE_OK) {
     printf("ERROR: %s\n", errmsg);
      return -1;
    }
 
    if(sqlite3_exec(handle,trigger,0,0,&errmsg) != SQLITE_OK) {
     printf("ERROR: %s\n", errmsg);
      return -1;
    }
 
    if(sqlite3_exec(handle,update_trigger,0,0,&errmsg) != SQLITE_OK) {
     printf("ERROR: %s\n", errmsg);
      return -1;
    }
 
    if(sqlite3_prepare_v2(handle,select_log,-1,&stmt,&tail) != SQLITE_OK) {
        printf("ERROR: Select wasn't executed!");
      return -1;
    }
 
    /** Output of the execution. **/
    printf("%s\n", select_log);
    printf("==========================================================\n");
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        printf("%d | ", sqlite3_column_int(stmt, 0));
        printf("%s | ", sqlite3_column_text(stmt, 1));
        printf("%s | ", sqlite3_column_text(stmt, 2));
        printf("%s\n", sqlite3_column_text(stmt, 3));
    }
    printf("==========================================================\n\n");
 
    /** Finish the statement. **/
    sqlite3_finalize(stmt);

}

Python:
    def log_trigger_database(self, cur):

        try:
            # Create the table 'log' used by the trigger.
            cur.execute("CREATE TABLE log(id integer PRIMARY KEY, \
                         project_old_name TEXT, project_new_name TEXT, \
                         date TEXT)")

            # Create the trigger.
            cur.execute("CREATE TRIGGER project_trigger \
                         UPDATE OF name_project ON project \
                         BEGIN \
                         INSERT INTO Log(project_old_name, project_new_name, date) \
                         VALUES(old.name_project, new.name_project, \
                         datetime('now')); \
                         END;")

            # Execute the UPDATE to check the trigger.
            cur.execute("UPDATE project SET name_project='Product W' \
                         WHERE number_project='3'")

            # Check if trigger works.
            cur.execute("SELECT * FROM log")
         
            # Output of the execution.
            print "SELECT * FROM log"
            print "=========================================================="
            for row in cur:
                print row[0], '|', row[1], '|', row[2], '|', row[3]
            print "==========================================================\n"
     
        except sqlite3.Error, e:
            # Throw an error if it occurs.
            print 'ERROR: ' % e.args[0]


As you can see, this function create the table 'log', create the trigger, update a specific project's name and execute a SELECT statement in the table 'log'. The output of SELECT statement is printed in the output stream.

Conclusion

If you don't want to use a DBMS, SQLite is a good alternative for small databases. Remember that SQLite is only a library who manipulates a file. So, a large amount of data can cause latency when you recover a data.

In Python, we have some differences from C and they will show in a next post.

Observation: The database figure will be changed for a better figure.

Sunday, February 5, 2012

Pyjamas: Um Web Toolkit prático e simples para o desenvolvimento de aplicações AJAX

Nesse novo post, gostaria de demonstrar um pouco sobre uma ferramenta que caiu como uma luva em um dos projetos que iniciei a pouco tempo: o framework Pyjamas. O Pyjamas se auto define como um compilador Python-to-JavaScritp. Isso significa, na verdade, que ele é capaz de gerar um script em JavaScript a partir de códigos feitos em Python.

Inclusive, as bibliotecas do Pyjamas incorporam um Web Toolkit capaz de gerar Web Widgets. Em outras palavras, com o Pyjamas você pode criar sites com visuais no estilo Desktop, por exemplo. Sites com menus dinâmicos, botões, barras, diálogos, etc. Por esse motivo, pode se dizer que o Pyjamas é uma ferramenta quase alternativa ao Google Web Toolkit (GWT). Só não é por completo pelo fato daquela utilizar chamadas das bibliotecas do GWT para suprir algumas deficiências que ela ainda possui.

No nosso caso, construir todo um sistema Web fazendo uso de AJAX, HTML e CSS seria muito custoso e levaria a muito tempo de desenvolvimento. Com esse Web Toolkit, nos preocupamos somente com a disposição dos elementos do site e com o estilo dele (CSS). Sobrando um enorme tempo para nos dedicar a funcionalidade e operacionalidade do sistema.


Exemplo do uso

Irei, a seguir, somente mostrar um breve exemplo do uso do Pyjamas, uma vez que você encontra muito material com qualidade no site da ferramenta.

Para inicio, você precisa obviamente da própria ferramenta. Há três modos de obtê-la: via apt-get (em sistemas Debian-like), fazendo o Download via link ou baixando o repositório git pelo,

git clone git://pyjs.org/git/pyjamas.git

Eu recomendaria o Download tanto do código-fonte quanto do repositótio git. A versão da ferramenta via apt-get é mais antiga e dá mais problemas na construção do que as citadas anteriormente.

Siga toda a instrução de compilação e construção do Pyjamas descrita nos arquivos do framework e pronto. Após construído, note que fora criado a pasta 'bin'. Todas as ferramentas provenientes do Pyjamas se encontram neste diretório:
  • pyjsbuild: compila o código em Python e constrói toda a sua página web com JavaScript;
  • pyjd: um Depurador (Debugger);
  • pyjscompile: o próprio compilador sem construção de output;
  • pyjampiler: também é (alternativo) um compilador um pouco menor que o pyjscompile;
Podemos construir cada classe em um arquivo separado fazendo as importações necessárias, porém iremos montar o script em um único arquivo para facilitar o exemplo.

Para iniciarmos nosso script, importamos as bibliotecas que serão utilizadas,

from pyjamas.ui.RootPanel import RootPanel
from pyjamas.ui.SimplePanel import SimplePanel
from pyjamas.ui.HorizontalPanel import HorizontalPanel
from pyjamas.ui import HasAlignment
from pyjamas.ui.Image import Image
from pyjamas.ui.Button import Button
from pyjamas.ui.ToggleButton import ToggleButton
from pyjamas.ui.MenuBar import MenuBar
from pyjamas.ui.MenuItem import MenuItem
from pyjamas import Window

Nesse exemplo, iremos mostrar a criação de uma Barra de Menus e dois botões, um normal e um toggle.

Começaremos pela classe que irá representar a Barra de Menus.

class MenubarExample(SimplePanel):
    def __init__(self):
        SimplePanel.__init__(self)
     
        menu1 = MenuBar(vertical=True)
        menu1.addItem("Open", getattr(self, "onMenuItemOpen"))
        menu1.addItem("Save As...", getattr(self, "onMenuItemSaveAs"))

        menu2 = MenuBar(vertical=True)
        menu2.addItem("Undo", getattr(self, "onMenuItemUndo"))
        menu2.addItem("Redo", getattr(self, "onMenuItemRedo"))
             
        menu3 = MenuBar(vertical=True)
        menu3.addItem("Help", getattr(self, "onMenuItemHelp"))
        menu3.addItem("About", getattr(self, "onMenuItemAbout"))

        menubar = MenuBar(vertical=False)
        menubar.addItem(MenuItem("File", menu1))
        menubar.addItem(MenuItem("Edit", True, menu2))
        menubar.addItem(MenuItem("About", True, menu3))
     
        self.add(menubar)

    def onMenuItemOpen(self):
        Window.alert("Item Open selected")

    def onMenuItemSaveAs(self):
        Window.alert("Item Save As selected")

    def onMenuItemUndo(self):
        Window.alert("Item Undo selected")

    def onMenuItemRedo(self):
        Window.alert("Item Redo selected")
    
    def onMenuItemHelp(self):
        Window.alert("Item Help selected")
 
    def onMenuItemAbout(self):
        Window.alert("Item About selected")

E a classe que corresponde a barra com os dois botões é apresentada a seguir:

class PanelExample(SimplePanel):
    def __init__(self):
        SimplePanel.__init__(self)
     
        hPanel = HorizontalPanel(BorderWidth=0,
                        HorizontalAlignment=HasAlignment.ALIGN_CENTER,
                        VerticalAlignment=HasAlignment.ALIGN_MIDDLE,
                        Width="110px",
                        Height="20px")
         
        newButton = Button("Click Me",
                        getattr(self, "onNewButtonClick"))
     
        newToggleButton = ToggleButton("Up", "Down",
                        getattr(self, "onToggleButtonClick"))
     
        hPanel.add(newButton)
        hPanel.add(newToggleButton)
        self.add(hPanel)

    def onNewButtonClick(self):
        Window.alert("New Button Selected ")

    def onToggleButtonClick(self):
        Window.alert("Toggle Button Selected")

Por fim, é necessário implementar uma classe que possua a função onModuleLoad() que incluirá os paineis e menus criados.

class ControlExample:
    def onModuleLoad(self):
        menubar = MenubarExample()
        RootPanel().add(menubar)
     
        panel = PanelExample()
        RootPanel().add(panel)

Finalizando, criaremomos a função main.

if __name__ == '__main__':
    app = ControlExample()
    app.onModuleLoad()

Este script pode ser construído via 'pyjsbuild nome_do_script.py'. Todos os arquivos produzidos estarão no diretório 'output'. Para debugá-lo, basta inserir o parametro '-d' no comando acima.

No arquivo HTML você pode incluir o CSS para melhorar a aparência de sua página. Um exemplo seria,

.gwt-MenuBar {
   background-color: #FFF;
   border: 1px solid #333;
   cursor: default;
}

.gwt-MenuBar .gwt-MenuItem {
   padding: 1px 4px 1px 4px;
   font-size: smaller;
   cursor: default;
}

.gwt-MenuBar .gwt-MenuItem-selected {
   background-color: #EEE;
}

A saída produzida por nosso código, juntamente com o CSS acima, pode ser mostrada na figura abaixo.

Barra de Menus, um botão comun e um toggle.
Concluíndo, procuramos introduzir neste artigo  uma ferramenta extremamente prática na construção de sites mais dinâmicos ou sistemas Web. Com a utilização do framework Pyjamas, o desenvolvedor ganha muito mais tempo no desenvolvimento das suas aplicações.

Para quem gosta da linguagem Python e de desenvolvimento Web, vale a pena experimentar o Pyjamas.


Referências


Monday, January 30, 2012

Uma visão básica e essencial sobre Autotools - Parte II


Nessa segunda parte veremos como gerar um makefile a partir do comando Automake, inserir bibliotecas e outros comandos e informações necessárias.

Na Parte I, geramos um script que verifica as dependências e configurações do sistema para a compilação dos códigos-fonte: o 'configure'. A partir da execução desse script, temos a geração do Makefile e assim podemos compilar nosso código.

Antes de continuarmos, vamos sanar o problema da falta do arquivo "config.h.in". Para isso, executamos simplesmente,

autoheader

Verificamos que, se executarmos o script 'configure' novamente, o erro "config.status: error: cannot find input file: `config.h.in'" não será exibido e ao invés disso, ele criará o arquivo "config.h".

Tal arquivo é o que garante a portabilidade do código no momento da compilação. Nele é possível colocar as definições necessárias para as diretivas de compilação, por exemplo.


Gerando um Makefile a partir do Automake

Uma das características mais interessantes dessas ferramentas, na minha opinião, é justamente essa: poder gerar um makefile completo e de forma automática. Primeiramente, devemos incluir o comando no nosso script que indica a criação de um Makefile automatico. Portanto, no arquivo "configure.ac" incluímos o seguinte trecho,

...
C_PREREQ([2.67])
AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])
AM_INIT_AUTOMAKE
AC_CONFIG_SRCDIR([src/helloworld.c])
AC_CONFIG_HEADERS([config.h])
...

Continuando, devemos agora renomear nosso simples Makefile criado inicialmente para 'Makefile.in',

mv Makefile Makefile.in

Ou seja, nosso makefile servirá como input para a criação do novo arquivo. E, antes de executar o comando principal, executamos,

aclocal

A execução cria o arquivo aclocal.m4 que por sua vez une todas as macros necessárias para a compilação, inclusive as definidas pelo programador, em um único arquivo.

Criamos o arquivo 'Makefile.am' para especificar os parametros a serem definidos pelo Automake. Abaixo um exemplo para nosso programa "hello world".

# Exemplo de Makefile.am

bin_PROGRAMS=helloworld
helloworld_SOURCES=src/helloworld.c

CLEANFILES=./*.o \
        helloworld

Enfim, executamos,

automake --add-missing --copy

Os parametros "--add-missing" e "--copy" fazem com que o automake copie arquivos necessários como o "install-sh" e "missing" que ainda não estão presente no nosso projeto.

A Saída da execução do comando em questão identificará a falta de alguns arquivos. A simples criação deles resolve o problema!

touch ./NEWS ./README ./AUTHORS ./ChangeLog

Os nomes dos arquivos são bem sugestivos às suas reais finalidades.


Incluindo bibliotecas específicas

Muitas vezes, nosso projeto necessita da importação de algumas bibliotecas e como elas são inseridas na configuração e geração do Makefile? A resposta é continuação desse tutorial.

Iremos utilizar duas bibliotecas a "math.h" e as bibliotecas da Glib.

Começando pela "math.h", alteremos o código do helloworld.c na pasta 'src/'.

// helloworld.c com Math.h

#include <stdio.h>
#include <math.h>

#define PI 3.1415926

int main(int argc, char *argv[]) {

float x = sin(PI/6);

printf("Seno de 60: %f\n", x);

return 0;
}

Inicialmente, devemos abrir o arquivo "configure.ac" e inserir o seguinte trecho em vermelho.

...
# Checks for libraries.
AC_CHECK_LIB(m, sin)
...

Lembre-se que quando compilamos, passamos o parâmetro "-lm" para incluir a "math.h". Logo o "m" representa tal parametro. A segunda entrada checa se existe a função "sin()" na biblioteca verificada.

Salve o arquivo "configure.ac" e execute,

autoreconf
make
./helloworld

Agora, a biblioteca "math.h" pode ser usada tranquilamente no projeto.

E se por um acaso, as libs estão em pastas específicas? Você pode adicioná-las antes da checagem acima usando,

LDFLAGS = "$LDFLAGS -L/local_da_sua_lib/"
CFLAGS = "$CFLAGS -I/local_da_sua_lib/"

No caso da Glib, quando pretendemos compilar um código-fonte que faz o uso da biblioteca usamos comumente o pkg-config passando o parametro: `pkg-config --cflags --libs glib-2.0`.

Para configurá-lo adequadamente devemos inserir o seguite código no arquivo 'configure.ac',

...
AC_CONFIG_HEADERS([config.h])

# Check libraries with pkg-config
PKG_CHECK_MODULES(GLIB, glib-2.0)

# Checks for programs.
AC_PROG_CC
...

Dessa forma, o script 'configure' irá verificar as dependências e adicionar o parâmetro citado automaticamente no Makefile gerado.

Por fim, toda a configuração necessária para incluir uma biblioteca na configuração do Automake usando duas maneiras diferentes de inclusão foi demonstrada acima.


O diretório autom4te.cache

Como fora dito na Parte I, nota-se que quando é executado o 'autoconf' uma pasta chamada autom4te.cache é criada. O intuito dela é guardar informações para que a execução de outras ferramentas como o 'autoheader' e o 'automake' seja facilitada. Ou seja, quando reconfiguramos alguns arquivos referentes ao 'automake' não é necessário executar toda vez o 'autoconf' porque os dados necessário já estão salvos (cached) no diretório 'autom4te.cache'. A sua presença não é vital para o projeto, mas a sua remoção força a execução do 'autoconf' toda vez que um comando precisar dos dados de saída do mesmo.


Conclusão

O Tutorial apresentado foi uma visão extremamente básica sobre a ferramenta GNU Autotools para que qualquer desenvolvedor interessado possa já configurar seu projeto facilmente e torná-lo portável. Há materiais na literatura e na internet de fácil acesso que abordam assuntos mais aprofundados. Inclusive, o próprio manual da ferramenta (como exemplo o Autoconf Manual) é um excelente guia de estudo avançado.


Referências Extras