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

Using Boost on OS X with Jetbrains' AppCode

So, after a serious pain in the butt getting Boost installed using the homebrew boost keg (see my previous post ), I decided to test things out using AppCode. Obviously, since this is a "3rd party library", a little massaging has to be done to get the libraries and headers found, and it's sufficiently obscure to deserve a post. I will list the procedure using my rig (OS X). You can extrapolate from this to your own kit. Right-click on your project icon, and select, "Project Settings..." , and scroll down to the "Search Paths" heading. About the third or so option down is "Header Search Paths" . Open that, and select either or both your type of build (Debug/Release), and then double click to the right of it under the "value" column. This will open up a window where you can add a path. Click the "+" and enter the path to the location of your copy of Boost's Headers. In my case: /usr/local/Cellar/boost/1....
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

Fun with Meteor, React, and React-Bootstrap

React-Bootstrap is pretty cool. I decided to play with it a bit.  Here are the basics. In an already set up Meteor project (set up for React), it is added thus: npm install --save react-bootstrap Once this is done, you also need to add a bootstrap library. It could either be the twitter bootstrap meteor package, or you can link to it. For the purpose of my demo, I just grabbed a couple links from the React-Bootstrap site that they had handy for pulling in from a CMS: index.html <head> <!-- Latest compiled and minified CSS --> <link href="https://maxcdn.bootstrapcdn.com/bootstrap/latest/css/bootstrap.min.css" rel="stylesheet"> </link> <!-- Optional theme --> <link href="https://maxcdn.bootstrapcdn.com/bootstrap/latest/css/bootstrap-theme.min.css" rel="stylesheet"> </link> </head> Now, let's make a layout, and then create a component tha...
Post a Comment
Read more