Skip to main content

Codeigniter vs. Kohana Database access speeds

I was doing some basic profiling for a project in which I needed the fastest raw speed I could get with database queries. I'm a fan of Codeigniter for projects that are suitable for it, but had heard from some that Kohana was faster, so I decided to do a very basic comparison of the two. I was using MAMP for OSX, and created a very small db, with a table that had 3 fields: (id), (first), and (last). The data sample was also very small, only a few records. The basic query I tested was a "SELECT * FROM [table]". There is of course nothing remotely scientific about this. It was just a quick ad dirty, very limited comparison. Take it as such. Versions used: CI2.1.3, Kohana 3.3.0.

Codeigniter

I really like Codeigniter (CI). But, one thing that is very evident from their own profiling functions, is that CI is a bit of a memory hog! Essentially, the same Controller function running in CI takes approximately 10X more memory than in Kohana! This in itself is not a reason not to use it. CI has bee used for a whole lot of projects, and is gaining in popularity. I continue to use it, knowing this. But credit where it's due: Kohana uses around 170,000 bytes of memory for the same functionality that CI uses 1,700,000 bytes.

Don't let the memory thing scare you, if you're new to this stuff. Your production server can easily handle the memory requirements of CI. And, Codeigniter has a lot more functionality available to it than Kohana does.

It is interesting to note, that there is not a lot of difference in execution time between CI using it's own Active Record functions, and PHP's mysql_xxx! CI Clearly has some very well written database code. The total time for the app was a bit longer ( no doubt due to the class navigation involved ) which more or less put the two on equal footing, but the query time was certainly faster using CI's ORM. 


Codeigniter with mysql_xxx

    $mysql = mysql_connect( 'localhost:8889', 'root', 'root' );
    mysql_select_db('cidb');
    $q = mysql_query("SELECT * FROM names");
    foreach ( mysql_fetch_assoc( $q ) as $row ) {
      echo $row;
    }

Time for this to execute: 0.1357 s
Total Time for app:         0.2137 s


Codeigniter with it's Active Record


     $this->output->enable_profiler(TRUE);
     $query = $this->db->get('names');
     foreach ( $query->result() as $row ){
 echo $row->first . " ";
 echo $row->last . "
";
     }

Time for this to execute: 0.1150 s
Total Time for app:         0.3800 s

Kohana

Kohana's Profiler requires some book end code. Here it is: 

Kohana's Profiler Book ends

    // Be sure to only profile if it's enabled
    if ( Kohana::$profiling === TRUE )
    {
        // Start a new benchmark
        $benchmark = Profiler::start( 'Your Category', __FUNCTION__ );
    }

    CODE UNDER TEST...

    if ( isset( $benchmark ) )
    {
        // Stop the benchmark
        Profiler::stop($benchmark);
    }

Kohana started as an off-shoot of CI, but since has been completely re-coded. CI wraps everything in a single, large object (which explains its larger memory footprint ), where as Kohana does not. Kohana does not have the quality of documentation that CI does, but the situation is improving all the time. Kohana also does not offer as many 'Helpers' and 'Libraries' as CI. Both frameworks are great choices, imho.


Long story short, the absolute fastest database access, and overall fastest executing database access methodology given the constraints of this 'quick and dirty' profile was plain old PHP mysql_xxx


Kohana with mysql_xxx


    $mysql = mysql_connect( 'localhost:8889', 'root', 'root' );
    mysql_select_db('cidb');
    $q = mysql_query("SELECT * FROM names");
    foreach ( mysql_fetch_assoc( $q ) as $row ) {
      echo $row;
    }
    $this->response->body( View::factory( 'profiler/stats' ) );

Time for this to execute: 0.004460 s
Total Time for app:         0.028532 s


Kohana with mysqli_xxx


    $mysqli = new mysqli();
    $mysqli->connect( 'localhost', 'root', 'root', 'cidb', '8889' );
    $result = $mysqli->query( "SELECT * FROM names");
    foreach ( $result->fetch_row() as $row ) {
      echo $row;
    }
    $this->response->body( View::factory( 'profiler/stats' ) );

Time for this to execute: 0.004965 s
Total Time for app:         0.105614 s


Kohana with Kohana's DB Object


    $r = DB::select()->from('names')->execute();
    foreach ( $r as $person ) {
      echo $person['first'];
    }
    $this->response->body( View::factory( 'profiler/stats' ) );

Time for this to execute: 0.017171 s
Total Time for app:         0.151900 s


Kohana with PDO


    $dbh = new PDO( "mysql:dbname=cidb; host=localhost; port=8889", 'root', 'root' );
    $q = "SELECT * FROM names";
    foreach ( $dbh->query( $q ) as $row ){
      $g = $row['first'];
    }
    $this->response->body( View::factory( 'profiler/stats' ) );

Time for this to execute: 0.128000 s
Total Time for app:         0.153443 s

Labels:
Location: Austin, TX 78727, USA

Comments

Post a Comment

Popular posts from this blog

Install current SBCL on OS X

You must have Command Line Tools installed. If you don't , this tutorial is not for you. Google: installation of XCode and Command Line Tools. Normally, I use brew to install things (when it offers a solution), but in this case the keg version was a couple minor version's off. And, there had been sufficient addition's that motivated me to want the current release. So, building from source was the path of least resistance. First, what not to do : The note's caution against using OS X's Terminal , as their make.sh script pukes a shit-ton of text during the build, and according to them, it can slow the build. I did not experience an issue with this, compared to other builds I've done in the past.   BUT , they also say build can be accomplished with other LISP's installed (you must have a lisp installed prior to building). OMFG , unless you want to wait a month of Sunday's, my experience building with CLISP was slower than the Molasses in January.  D
Post a Comment
Read more

React Simplicity

This is just a quick intro to React to show how easy it is on a very basic level. React is often compared to Angular, but the two are very different: Angular is more of a framework , whereas React is more of a library . So, with React, we can make Components, and in so doing, we can intersperse plain Javascript to instill behavior. This article is not showing (or using) best practices, or a recommended structure. It's purpose is only to show how easy the basic mechanics of React are. Let's grab the getting started cli from React's page npm install -g create-react-app create-react-app my-app cd my-app npm start After this is done, and you have the project displayed in your browser, let's experiment. A boiler-plate header we can use for each new class can be as simple as: /src/Foo.js import React, { Component } from 'react'; class Foo extends Component { render(){ return(); } } export default Foo; So, all that we need to change to get st
Post a Comment
Read more

Dead Simple React.js with Meteor

I spent a little time exploring the patterns involved in using React.js with Meteor. It's incredibly easy, it turns out. I'll show some examples here. The setup: meteor add kadira:flow-router npm install react react-dom react-mounter npm install react-addons-pure-render-mixin meteor add react-meteor-data Then of course remove all blaze related meteor packages. Ok, Some basic component patterns: Let's create one that accepts a single argument: Hello.jsx import React from 'react'; export const Hello = ({name}) => ( <div>Hello, {name}</div> ); That's all there is to it. Now, let's see a pattern for a component that takes two arguments. We can see that to add further arguments, we can just tack them on after the first two: TwoArgs.jsx import React from 'react'; export const TwoArgs = ({one, two}) => ( <div> <h2>TwoArgs!</h2> <h3>One is: {one}</h3> <h3>Two is: {two}&
Post a Comment
Read more