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

Kicking things off

My purpose here is to document various thoughts and findings as things come up, or come to mind.  All strictly technical, and kind of a development diary of sorts.  While ideally, others may find these things useful, my main intent is to have them here for my reference ;-) Still, I'll try to write them in tutorial fashion
Post a Comment
Read more

Passing Functions and Lambdas into Functions with Ruby

Ruby's New Style of Lambda Functions f = ->( m ) { p m } f.call( 1 ) #=> 1 Which of course means the same thing as: f = lambda { |n| p n } f.call(1) #=> 1 Ruby Proc Objects p = Proc.new { |n| p n + 2 } p.call(2) #=> 4 Using a Function as a Closure in Ruby def domo( k ) ->(m) { p m + k } end z = domo( 5 ) z.call( 5 ) #=> 10 Function :domo takes a single parameter. Within :domo , we create a lambda that takes a single parameter, and adds that parameter to the value :domo takes in as its parameter. Then, we assign z to be the result of the lambda in :domo with its 'k' parameter loaded with 5. When z is called, we pass (another) 5 to it. This parameter loads the lambdas n parameter. The lambda executes, essentially adding n (5) + k (5) and yielding the result of 10. The thing about closures such as this is, we can load the initial value of the lambda to be whatever we want it to be when assigning the function :domo '...
Post a Comment
Read more

Add pre-compiled Elixir on OS X

So, I've been a big Erlang fan for a few years now, and then found out about Elixir :  what I would describe as kind of a Ruby -ish creamy frosting on top of Erlang . But I'll address more on both in future. Right now, I thought I'd just give a quick and dirty way to add Elixir , if you've already got Erlang installed (hint: check-out this Erlang Solutions link for a pre-compiled Erlang solution).  You can also use brew to install both , but I have found that with the simplicity of brew, you give up having the most current version of software.  In both cases. The pre-compiled zip for the most current version of  Elixir can be found here .  Unzipping reveals a folder containing everything you need.  For simplicity's sake, keeping everything pertaining to Elixir all within this folder makes the most sense.  By doing so, all that's needed is to position the folder, and then make links to all the executables in a directory already in our path.  Through t...
Post a Comment
Read more