I am an experienced developer with my own transport and will come to you for an initial no obligation face to face meeting.

I am also considering fulltime employment with salary offers exceeding R35K.

Call  / SMS me on 079 9111 855

Email info@mydeveloper.co.za.

I will get to you as soon as possible.

Brief Profile

I am an innovative, dynamic and self-motivated web/php  developer with proven solid technical skills in programming, advanced website and web based systems development, deployment and maintenance. I am a resourceful and analytical problem solver, strategic thinker, effective communicator at all levels, both verbally and in writing. I am a natural leader with a yearning passion for quality and success and I quickly acclimatize to new environments

Key Skills

Programming Skills: PHP,ASP, MVC Frameworks – Code Igniter , CakePHP ,SOAP , REST , HTML ,Advanced XHTML and CSS , W3C Web Standards, Jquery , Mootools ,  Javascript , JSON , Graphic design ,and Photo editing. Proficient user of Dreamweaver CS23/CS4, Photoshop CS3 , Illustrator , Fireworks ,  Dreamweaver , Contribute.

Open Source Platforms: Joomla , Drupal , WordPress , OsCommerce , ZenCart , CubeCart , OpenCart

Web Servers: Apache Http Server, Apache Tomcat 4.0. , IIS

DBMS: MySql, MS SQL,

Analysis/Design Methodologies: UML, OOAD, Unified Modeling Process.

If you require a PHP developer for your project

please call Mark on 079 9111 855 or email info@mydeveloper.co.za.

If you are considering freelance work, make sure that you think through the many advantages and disadvantages of freelancing before making any decisions.

Advantages Of Freelance Work
There are many advantages of freelance work. One of the greatest advantages of freelance work is the ability to work from home. No more need for work clothing, commuting time, commuting expenses, sharing an office, working in a cubicle or inane chats during tea breaks.

Another great advantage is the ability to be your own boss. No more being assigned projects you don’t want, having to work with team-mates you don’t respect or worrying about who is looking over your shoulder. Also, freelancing allows you to use a variety of skills on a variety of projects all at the same time. This can be fantastic for individuals who enjoy diverse tasks and topics and work best when they have multiple balls to keep in the air.

Individuals who work well under pressure and are well organised may find freelancing a great idea as they take on all responsibilities for every project, something that is not for the faint of heart!

Disadvantages Of Freelance Work
Freelancing does have its disadvantages as well. One great disadvantage it is that it is a very isolated way to work. When you work from home it is easy to be alone for hours and even days on end. Contact with others often comes in the form of phone calls, faxes or emails so a freelance must often make a point to leave the house and see other people.

Another disadvantage is having to be your own boss. Freelancing can be a nightmare for people who are not good with deadlines, following up on projects, collecting payments or enforcing contract clauses. Also, freelance work necessarily requires a lot of paperwork. Contracts, invoices, client communication, marketing supplies – all of this must be organised and used effectively by a freelance worker. People who are inherently uncomfortable with such organisation often find freelance work a challenge, particularly when it comes to organising a client folder or getting paperwork ready for taxes.

Finally, freelance work is often described as a feast or famine profession. This can make it hard to anticipate weekly, monthly and especially yearly profits, and it can be hard to anticipate when the payments will actually come in. This can be nerve-wracking for many people, so it must be remembered that those who do not enjoy risks may not enjoy freelance work.

There are many advantages and disadvantages to freelance work, just as there are to any other type of job. If you want to learn more about what it is really like to be a freelance worker, contact an individual in your area and see if you can pick their brains or even shadow them for a day. Learning from someone in the trenches is often the best way to decide if freelancing is for you.

I’m pitting these two frameworks against each other but there really isn’t a clear winner. Each has its strengths and weaknesses and ultimately falls to what your preference for certain features might be.
Why compare these two?

CakePHP and CodeIgniter are quite similar in their approach on a number of things, including their support for PHP4. Any mention of one inevitably leads to someone mentioning the other.

They both attempt to create an MVC architecture which simply means they separate the (data) Model from the Controller (which pulls data from the model to give to the view) from the View (what the user sees).

They both use Routing which takes a URL and maps it to a particular function within a controller (CakePHP calls these actions). CodeIgniter supports regular expressions for routing, whereas you’ll have to wait until CakePHP 1.2 for that feature. Correction: CakePHP 1.1 supports regular expression for routing but it’s not detailed in the manual and is getting updated in 1.2.

They both support Scaffolding which is an automated way of generating a view based on the model. Scaffolding is meant for simple prototyping and CodeIgniter takes it a step further by requiring a keyword in the URL to even access the scaffolding. I’m guessing one could omit the keyword, leaving this feature essentially optional. I prefer not to have to use the keyword as I sometimes build personal projects not intended for public eyes and using a keyword would be a nuisance.

And the list goes on…
Approach to Simplicity

I believe much of CodeIgniter’s appeal is its simplicity in its approach. Most of the work is done in the controller, loading in libraries, getting data from the model, and pulling in the view. Everything is in plain sight and you can really see how things work.

CakePHP’s simplicity comes via automation (euphemistically referred to as “automagic”). It makes the coding process quicker but harder to figure out “what is going on” without popping your head into the core. For me, I like to understand how everything works and I’ve had to poke around under the hood more than once. For people just getting started, things probably look a little daunting.
Working with Models

CodeIgniter’s model handling is fairly straightfoward and basically allows you to mimic a standard SQL query with a few straightforward commands like these examples:

$query = $this->db->getwhere(‘mytable’, array(id => $id), $limit, $offset);

$this->db->select(‘title’)->from(‘mytable’)->where(‘id’, $id)->limit(10, 20);
$query = $this->db->get();

Note: the method chaining in the second part of this example is only available in PHP5.

You can also create a model object, load it in and build custom methods to handle a custom task. You’d want to do this in the model and not the controller to help isolate code into the MVC silos.

CakePHP takes a slightly different route by automatically loading in the model that matches the current controller (controllers tend to be named similarly to the models they are associated with). You can turn off this automated loading and even assign different models that should be loaded by the controller instead.

CakePHP also takes things further by establishing all the model associations for you, allowing for some really easy querying. For example, assuming I’m in a controller named post_controller, I could do the following:

$this->Post->Comment->findAllByPostId($id)

I chose this particular query because it shows two different concepts. The first is the fact that I can access the Comment model via the Post model (assuming I’ve defined that association in the Post model). The second is the fact that I have a method called findAllByPostId. CakePHP allows records to be grabbed via findByX and findAllByX queries where X is equal to the field name you’re trying to find.

Where I think Cake shines is in its ability to pull in all associated data automatically. Take the following query as an example:

$this->Post->findById($id)

This query would automatically pull in all the comments associated with this Post. Really handy stuff.
Validation

When working with models, you’ll inevitably have to handle data validation. Data validation in CodeIgniter is handled via a validation class. A set of rules get defined and assigned to the validation object. The validation object automatically (I assume) validates the data passed via the URL or form. From there, you can decide how that gets handled. The validation class can also help automate some of the process of setting error messages for specific fields.

CakePHP handles its validation through the model itself in one of two ways. The first uses a single test against each field defined in a validate variable declared in the model. This works okay for simple stuff but it quickly becomes a cumbrance. Beyond simple validation, I take advantage of the beforeSave callback to perform any custom validation, invalidating any fields that fail.

It’s a toss up for me as to which one “wins”. CakePHP 1.2 will have its validation system reworked a bit to allow for more flexibility.
Views

CakePHP handles this fairly well by using a default layout (which you can easily switch at runtime). The layout has two variables be default: title_for_layout and content_for_layout. Each action automatically links to a particular view which gets spat into place. Again, it’s the “automagic” approach. As long as you name your files a specific way, controllers automatically get linked to models and views. It’s easy enough to override all of this, too, and define your own layouts or view files. There’s no convenient way to get the generated view data, however, making custom built caching mechanisms difficult to implement.

CodeIgniter takes a very straightforward approach: like include files, almost. Each file gets loaded in and processed. There’s a templating class but it doesn’t simplify things much beyond the built-in view handling. You can mimic the CakePHP approach by always including the header and footer calls but it’s not as seamless. CodeIgniter offers hooks allowing view and caching mechanisms to be overridden and replaced with a custom system.
Out of the Box Features

CodeIgniter in my mind wins this hands down with classes for FTP, Email, File Uploading, XMLRPC, Zip encoding and more.

CakePHP on the flip side comes pretty light but tries to make up for it using the Bakery. You can, like CodeIgniter, easily drop in 3rd party classes for any features you might need. Interestingly, although I haven’t tried it, you could probably drop in many of the CI classes into CakePHP without issue.
Auto-loading

CakePHP allows for application-wide changes to be done via the base application controller that all other controllers inherit from. Likewise, you can create global model methods using the application model file. However, you can fine tune things at the controller level using any of the controller-level callbacks (beforeFilter, afterFilter and beforeRender). Things like auto-loading helpers and components can also be specified easily at the individual controller level.

CodeIgniter allows for the auto-loading of helpers, libraries and plugins but does this application-wide.
Documentation

Documentation is key to understanding any framework well enough to develop within it.

CodeIgniter has a complete list of all components with each method and property documented within. CI also has forums and a wiki which feature a lot of user-submitted code.

CakePHP, on the other hand, isn’t as well organized. The manual is starting to show its age with some sections not really going much beyond what the API offers. Because of the format of the original documentation, you can also get it in other formats such as CHM and PDF. CakePHP has the Bakery which contains user-submitted articles, components, etc. The dev team also hangs out heavily on the IRC channel (#cakephp at irc.freenode.net). Finally, there’s the CakePHP Google Group which is pretty active.
Final Verdict

I’m a pretty pragmatic individual and I honestly feel that these two frameworks have a lot going for them. They take a much simpler approach to application development than the complexity that is something like Symfony.

I’m still personally a fan of CakePHP over CodeIgniter for much of the “automagic” that I mentioned. And it’s shortcomings have been getting addressed with each new iteration (1.2 will be a considerable leap over 1.1 but it will still be awhile before it’s released).

MySQL Table

Let’s begin by creating a database table.

CREATE TABLE `users` (
    `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
    `oauth_provider` varchar(10),
    `oauth_uid` text,
    `username` text,
    PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1;

Quite simple: we will be setting up a table for user information with id, username, first and last name, the URL to the user’s picture, and registered date. Also, we’re adding both an oauth_provider and oauth_uid fields, to distinguish between different third party open authentication protocols and their identifiers. For example, let’s say that, next week, you decide that it’s a good idea to also let Twitter users in. Easy; you just set another value to the oauthprovider, and avoid duplicating oauthuid values.

The Facebook App

Let’s begin by creating a new application. Give it a name and agree to the terms and conditions. Next, grab both the API Key and Secret in the basic tab as shown below.

On the canvas tab, set both the Canvas URL and Post-Authorize Redirect URL to your localhost and path that the script will process — something like http://localhost.com/login_facebook.php?. Note the question mark at the end and the domain; both are required by Facebook. Simply set your hosts file to a valid domain name.

On the connect tab, set the Connect URL to the same value and set localhost.com (or the one you are using) as the Base Domain.

Now save, download the client library, and unzip facebook.php in the srcdir to a new directory created in the root.

Step 2. The Callback

The authentication flow has three steps:

1. The local script generates a URL asking the user for permission
2. Facebook returns to the Canvas URL specified with a GET parameter
3. The GET parameter authenticates the session

Let’s make a quick test before registering and login.

# We require the library
require("facebook.php");

# Creating the facebook object
$facebook = new Facebook(array(
    'appId'  => 'YOUR_APP_ID',
    'secret' => 'YOUR_APP_SECRET',
    'cookie' => true
));

# Let's see if we have an active session
$session = $facebook->getSession();

if(!empty($session)) {
    # Active session, let's try getting the user id (getUser()) and user info (api->('/me'))
    try{
        $uid = $facebook->getUser();
        $user = $facebook->api('/me');
    } catch (Exception $e){}

    if(!empty($user)){
        # User info ok? Let's print it (Here we will be adding the login and registering routines)
        print_r($user);
    } else {
        # For testing purposes, if there was an error, let's kill the script
        die("There was an error.");
    }
} else {
    # There's no active session, let's generate one
    $login_url = $facebook->getLoginUrl();
    header("Location: ".$login_url);
}

Now, go to http://localhost.com/login_facebook.php, and let’s see what happens. If you are redirected to Facebook and requested for permission, we are on the right track.

However, there might be two issues. The first one: if you’re redirected to Facebook, but it shows an error, there might be a missing value in the configuration. Go back to your application settings and check both the Connect and Canvas tabs and make sure the fields are ok as described above.

There might be another issue, where you see an error, like “Uncaught CurlException: 60: SSL certificate problem, verify that the CA cert is OK.” This happens because of the CURL settings. You’ll have to open facebook.php, find the makeRequest() method, and, inside the function, find this line:

$opts = self::$CURL_OPTS;

Immediately following it, add:

$opts[CURLOPT_SSL_VERIFYPEER] = false;

I hate hacking libraries, but I haven’t found another way. Well, let’s continue with user registration. I’ve also added a try/catch statement, because, if there’s an old session keys in the GET params in the URL, the script will die with a horrible error.

Step 3. Registration and Authentication

We’ll next be working with MySQL. Please note that I will not implement a data sanitizer, since I want to keep the code as short and on task as possible. Please keep this in mind: always sanitize your data.

First, let’s connect to the database.

mysql_connect('localhost', 'YOUR_USERNAME', 'YOUR_PASSWORD');
mysql_select_db('YOUR_DATABASE');

Now, let’s work on the $session conditional, in case we have a session.

# We have an active session; let's check if we've already registered the user
$query = mysql_query("SELECT * FROM users WHERE oauth_provider = 'facebook' AND oauth_uid = ". $user['id']);
$result = mysql_fetch_array($query);

# If not, let's add it to the database
if(empty($result)){
    $query = mysql_query("INSERT INTO users (oauth_provider, oauth_uid, username) VALUES ('facebook', {$user['id']}, '{$user['name']}')");
    $query = msyql_query("SELECT * FROM users WHERE id = " . mysql_insert_id());
    $result = mysql_fetch_array($query);
}

Note that I’m querying the database, looking for facebook as a oauth_provider; it’s generally a good idea, if you want to accept other OAuth providers (as twitter, Google Accounts, Open ID, etc.) and a oauth_uid, since it’s the identifier the provider gives to its user accounts.

The oauth_provider field could potentially lead to bad performance if we leave it as a text field type. As such, the best option is setting it to an ENUM type.

We have now a $result var with the values queried from the database. Let’s next add some sessions. Add this line at the beginning of your script.

session_start();

After the empty($result) conditional, append the following:

if(!empty($user)){
    # ...

    if(empty($result)){
        # ...
    }

    # let's set session values
    $_SESSION['id'] = $result['id'];
    $_SESSION['oauth_uid'] = $result['oauth_uid'];
    $_SESSION['oauth_provider'] = $result['oauth_provider'];
    $_SESSION['username'] = $result['username'];
}

As it makes little sense to authenticate a user who is already logged in, just below the session_start() line, add:

if(!empty($_SESSION)){
    header("Location: home.php");
}

And in the scripts which require authentication, just add:

session_start();
if(!empty($_SESSION)){
    header("Location: login_facebook.php");
}

And if you want to display the username, access it as an array.

echo 'Welcome ' . $_SESSION['username'];
# or..
echo 'Welcome ' . !empty($_SESSION) ? $_SESSION['username'] : 'guest';

Step 4. Additional Methods

Facebook has a ton of connect features, but here are four that I’ve found to be the most useful.

Legacy Methods

I might be missing something, but the FQL seems more flexible and easy than the Graph API. Fortunately, Facebook still lets developers use it, altough with the new library, it has changed a bit.

If you want the user id, first name, last name, squared thumbnail for the user picture, the biggest user picture available, and his or her gender, you can use the users.getInfo method.

    $uid = $facebook->getUser();
    $api_call = array(
        'method' => 'users.getinfo',
        'uids' => $uid,
        'fields' => 'uid, first_name, last_name, pic_square, pic_big, sex'
    );
    $users_getinfo = $facebook->api($api_call);

You can check the full list of fields available for Users.getInfo.

It is possible to achieve the same result, using FQL.

    $uid = $facebook->getUser();
    $fql_query  =   array(
        'method' => 'fql.query',
        'query' => 'SELECT uid, first_name, last_name, pic_square, pic_big, sex FROM user WHERE uid = ' . $uid
    );
    $fql_info = $facebook->api($fql_query);

Here’s the list of tables which can be accessed with FQL, as well as the fields available for the table users.

Extended Permissions

Facebook provides applications with some interaction with the user’s data – just as long as it’s authorized. With the old API, the authorization for additional permissions was exclusively available for the Javascript SDK (altough I’m not quite sure). With the new API, we can easily redirect the user to an authorization dialog in Facebook, and return to our site after the access is either granted or denied.

In the following example, we will be redirecting a user to authorize posts status updates, photos, videos and notes, the user’s real email address, birthday and access to photos and videos.

$uid = $facebook->getUser();

# req_perms is a comma separated list of the permissions needed
$url = $facebook->getLoginUrl(array(
    'req_perms' => 'email,user_birthday,status_update,publish_stream,user_photos,user_videos'
));
header("Location: {$url} ");

Here’s a full list of permissions. Note that you can specify both the url to direct to if the user accepts and the url to be redirected to if the user denies. The key for these array elements are next and cancel_url, respectively. Here’s a quick example:

$url = $facebook->getLoginUrl(array(
    'req_perms' => 'email',
    'next' => 'http://localhost.com/thanks.php',
    'cancel_url' => 'http://localhost.com/sorry.php'
));

If not specified, the default is the requesting script’s location.

Checking for Extended Permissions

Since the user can easily revoke permissions, the application should always check if a given permission is granted before using it, specially if it’s about publishing something. We will have to use the legacy API, as it seems it’s not fully implemented with the new one yet.

    $uid = $facebook->getUser();

    # users.hasAppPermission
    $api_call = array(
        'method' => 'users.hasAppPermission',
        'uid' => $uid,
        'ext_perm' => 'publish_stream'
    );
    $users_hasapppermission = $facebook->api($api_call);
    print_r($users_hasapppermission);

The ext_perm will only support the old list of available permissions.

Publishing to the Wall

Let’s post something to the wall after verifying the user has the publish_stream permission.

    # let's check if the user has granted access to posting in the wall
    $api_call = array(
        'method' => 'users.hasAppPermission',
        'uid' => $uid,
        'ext_perm' => 'publish_stream'
    );
    $can_post = $facebook->api($api_call);
    if($can_post){
        # post it!
        $facebook->api('/'.$uid.'/feed', 'post', array('message' => 'Saying hello from my Facebook app!'));
        echo 'Posted!';
    } else {
        die('Permissions required!');
    }

Essentially, we are making an API call to /<user_id>/feed, using the POST method (second argument) and an array as a third argument for the data to be sent. In this case, this third argument supports message, link, picture, caption, name and description. Here’s the code:

$facebook->api('/'.$uid.'/feed', 'post', array(
    'message' => 'The message',
    'name' => 'The name',
    'description' => 'The description',
    'caption' => 'The caption',
    'picture' => 'http://i.imgur.com/yx3q2.png',
    'link' => 'http://net.tutsplus.com/'
));

Here’s how it is posted.

Some Additional Information you Should Know:

The user can easily revoke permissions with two clicks in his or her wall. You should heavily test what might happen if a user revoked one or more permissions that are vital for the proper functioning of your website, or even if the application is fully removed. This is important.

• In Application Settings you can remove the application entirely by clicking the x at the right side.
• You can remove permissions individually in the Granted Additional Permissions section.

5. Conclusion

While Facebook’s authentication capabilities are indeed useful, since so many people are on Facebook these days, using it as the only method of authentication in a site is not recommended. What about those who don’t have Facebook accounts? Are they not allowed to access your application? Thanks for reading!

MVC for Beginners

Model-View-Controller (MVC) is probably one of the most quoted patterns in the web programming world in recent years. Anyone currently working in anything related to web application development will have heard or read the acronym hundreds of times. Today, we’ll clarify what MVC means, and why it has become so popular.

Ancient History…

MVC is not a design pattern, it is an Architectural pattern that describes a way to structure our application and the responsibilities and interactions for each part in that structure.

It was first described in 1979 and, obviously, the context was a little bit different. The concept of web application did not exist. Tim Berners Lee sowed the seeds of World Wide Web in the early nineties and changed the world forever. The pattern we use today for web development is an adaptation of the original pattern.

The wild popularization of this structure for web applications is due to its inclusion in two development frameworks that have become immensely popular: Struts and Ruby on Rails. These two environments marked the way for the hundreds of frameworks created later.

MVC for Web Applications

The idea behind the Model-View-Controller architectural pattern is simple: we must have the following responsibilities clearly separated in our application:

The application is divided into these three main components, each one in charge of different tasks. Let’s see a detailed explanation and an example.

Controller

The Controller manages the user requests (received as HTTP GET or POST requests when the user clicks on GUI elements to perform actions). Its main function is to call and coordinate the necessary resources/objects needed to perform the user action. Usually the controller will call the appropriate model for the task and then selects the proper view.

Model

The Model is the data and the rules applying to that data, which represent concepts that the application manages. In any software system, everything is modeled as data that we handle in a certain way. What is a user, a message or a book for an application? Only data that must be handled according to specific rules (date can not be in the future, e-mail must have a specific format, name cannot be more than x characters long, etc).

The model gives the controller a data representation of whatever the user requested (a message, a list of books, a photo album, etc). This data model will be the same no matter how we may want to present it to the user, that’s why we can choose any available view to render it.

The model contains the most important part of our application logic, the logic that applies to the problem we are dealing with (a forum, a shop, a bank, etc). The controller contains a more internal-organizational logic for the application itself (more like housekeeping).

View

The View provides different ways to present the data received from the model. They may be templates where that data is filled. There may be several different views and the controller has to decide which one to use.

A web application is usually composed of a set of controllers, models and views. The controller may be structured as a main controller that receives all requests and calls specific controllers that handles actions for each case.

Let’s See an Example

Suppose we’re developing an online book store. The user can perform actions such as: view books, register, buy, add items to current order, create or delete books (if he is an administrator, etc.). Let’s see what happens when the user clicks on the fantasy category to view the titles we have available.

We will have a particular controller to handle all books-related actions (view, edit, create, etc). Let’s call it books_controller.php for this example. We will also have a model, for example book_model.php, handling data and logic related to the items in the shop. Finally we will have a series of views to present, for example, a list of books, a page to edit books, etc.

The following figure shows how the user request to view the fantasy books list is handled:

The controller (books_controller.php) receives the user request [1] as an HTTP GET or POST request (we can also have a central controller, for example index.php receiving it and then calling books_controller.php).

The controller examines the request and the parameters and calls the model (book_model.php) asking him to return the list of available fantasy books [2].

The model is responsible for getting that information from the database (or wherever it is stored) [3], apply filters or logic if necessary, and return the data representing the list of books [4].

The controller will use the appropriate view [5] to present these data to the user [6-7]. If the request came from a mobile phone, a view for mobile phones will be used, if the user has a particular skin selected, the corresponding view will be chosen, and so on.

What are the Advantages?

The most obvious advantage we gain using MVC is a clear separation of presentation (the interface with the user) and application logic.

Support for different types of users using different types of devices is a common problem these days. The interface presented must be different if the request came from a desktop computer or from a cell phone. The model returns exactly the same data, the only difference is that the controller will choose a different view to render them (we can think of a different template).

Apart from isolating the view from the business logic, the M-V-C separation reduces the complexity when designing large applications. The code is much more structured and therefore easier maintain, test and reuse.

Ok, but Why a Framework?

When you use a framework, the basic structure for MVC is already prepared and you just have to extend that structure, placing your files in the appropriate directory, to comply with the Model-View-Controller pattern. Also you get a lot of functionality already written and thoroughly tested.

Take cakePHP as an example MVC framework. Once you have it installed, you’ll see three main directories:

• app/
• cake/
• vendors/

The app folder is where you place your files. It is your place to develop your part of the application.

The cake folder is where cakePHP has its files and where they have developed their part (main framework functionality).

The vendors folder is for third-party PHP libraries if needed.

Your working place (app directory) has the following structure:

• app/
  • config/
  • controllers/
  • locale/
  • models/
  • plugins/
  • tests/
  • tmp/
  • vendors/
  • views/
  • webroot/

Now you have to put your controllers in the controllers directory, your models in the models directory and your views in… the views directory!

Once you get used to your framework, you’ll be able to know where to look for almost any piece of code you need to modify or create. This organization alone makes maintainability a lot easier.

Let’s Framework our Example

Since this tutorial is not intended to show you how to create an application using cakePHP, we’ll use it only to show example code for the model, view and controller components and comment on the benefits of using an MVC framework. The code is oversimplified and not suitable for real applications.

Remember we had a book store and a curious user who wants to see the complete list of books in the fantasy category. We said that the controller will be the one receiving the request and coordinating the necessary actions.

So, when the user clicks, the browser will be requesting this url:

 www.ourstore.com/books/list/fantasy

CakePHP likes to format URLs in the form /controller/action/param1/param2 , where action is the function to call within the controller. In the old classic url format it would be:

 www.ourstore.com/books_controller.php?action=list&category=fantasy

Controller

With the help of cakePHP framework, our controller will look something like this:

<?php

class BooksController extends AppController {

 function list($category) {

 $this->set('books', $this->Book->findAllByCategory($category));

 }

 function add() { ... ... }

 function delete() { ... ... }

 ... ... } ?>

Simple, isn’t it?. This controller will be saved as books_controller.php and placed in /app/controllers. It contains the list function, to perform the action in our example, but also other functions to perform other book-related actions (add a new book, delete a new book, etc).

The framework provides a lot of things for us and only one line is necessary to list the books. We have base classes with the basic controller behavior already defined, so we inherit from them (AppController which inherits from Controller).

All it has to do in the list action is call the model to get the data and then choose a view to present it to the user. Let’s explain how this is done.

this->Book is our Model, and this part:

 $this->Book->findAllByCategory($category)

is telling the model to return the list of books in the selected category (we’ll see the model later).

The set method in the line:

 $this->set('books', $this->Book->findAllByCategory($category));

Is the controller way to pass data to the view. It sets the books variable to the data returned by the model and makes it accessible to the view.

Now we just have to render the view, but this will be done automatically by cakePHP if we want the default view. If we need any other view we just have to call it explicitly using the render method.

Model

The model is even more simple:

<?php

class Book extends AppModel { 

}

?>

Why empty? Because it inherits from a base class that provides necessary functionality and we have followed the CakePHP name conventions to allow the framework to do other tasks automatically. For example, cakePHP knows, based on names, that this model is used in BooksController and that it will access a database table called books.

With this declaration only we have a book model capable of reading, deleting or saving data from the database

The code will will be saved as book.php and placed in /app/models.

View

All we have to do now is creating a view (at least one) for the list action. The view will have the HTML code and a few (as few as possible) PHP lines to loop through the books array provided by the model.

<table> <tr> <th>Title</th> <th>Author</th> <th>Price</th> </tr>

<?php foreach ($books as $book): ?> <tr> <td> <?php echo $book['Book']['title']; ?> </td> <td> <?php echo $book['Book']['author']; ?> </td> <td> <?php echo $book['Book']['price']; ?> </td> </tr> <?php endforeach; ?>

</table>

As we can see, the view doesn’t produce a complete page, just an HTML fragment (a table in this case). This is because CakePHP provides another way to define the layout of the page, and the views are inserted into that layout. The framework also provides us with some helper objects to make common task easy when creating these HTML excerpts (insert forms, links, Ajax or JavaScript).

We make this the default view saving it as list.ctp ( list is the name of the action and ctp means cake template) and placing it in /app/views/books (inside books because these are views for books controller actions).

And this completes the three components with the help of CakePHP framework!

Conclusion

We have learned what is probably the most commonly used architectural pattern today. We must be aware though that when we talk about patterns in the programming world, we are talking about flexible frames, to be tailored to the particular problem at hand. We will find implementations introducing variations on the structure we have seen, but the important thing is that, in the end, the pattern helps us gain a clear division between responsibilities and better maintainability, code-reuse, and testing.

We have also seen the advantages of using an MVC framework that provides us with a basic MVC skeleton and a lot of functionality, improving our productivity and making the development process easier. Thanks for reading!

CodeIgniter is a web application framework for PHP. It enables developers to build web applications faster, and it offers many helpful code libraries and helpers which speed up tedious tasks in PHP. CodeIgniter is based on a modular design; meaning that you can implement specific libraries at your discretion – which adds to the speed of the framework. This tutorial will attempt to show you the basics of setting up the framework, including how to build a basic hello world application that uses the MVC approach.

Why a Framework?

Frameworks allow for structure in developing applications by providing reusable classes and functions which can reduce development time significantly. Some downsides to frameworks are that they provide unwanted classes, adding code bloat which makes the app harder to navigate.

Why CodeIgniter?

CodeIgniter is a very light, well performing framework. While, it is perfect for a beginner (because
of the small learning curve), it’s also perfect for large and demanding web applications. CodeIgniter is developed by EllisLab and has thorough, easy to understand
documentation. Below is a list of reasons of what makes CodeIgniter a smart framework to use?

• Small footprint with exceptional performance
• MVC approach to development (although it is very loosely based which allows for flexibility)
• Generates search engine friendly clean URLs
• Easily extensible
• Runs on both PHP 4 (4.3.2+) and 5
• Support for most major databases including MySQL (4.1+), MySQLi, MS SQL, Postgres, Oracle, SQLite,
  and ODBC.
• Application security is a focus
• Easy caching operations
• Many libraries and helpers to help you with complex operations such as email, image manipulation,
  form validation, file uploading, sessions, multilingual apps and creating apis for your app
• Most libraries are only loaded when needed which cuts back on resources needed

Why MVC?

For starters, MVC stands for Model, View, Controller. It is a programing pattern used in developing
web apps. This pattern isolates the user interface and backend (i.e. database interaction from each other. A successful
implementation of this lets developers modify their user interface or backend with out affecting
the other. MVC also increases the flexibly of an app by being able to resuse models or views over
again). Below is a description of MVC.

• Model: The model deals with the raw data and database interaction and will contain functions
  like adding records to a database or selecting specific database records. In CI the model
  component is not required and can be included in the controller.
• View: The view deals with displaying the data and interface controls to the user with.
  In CI the view could be a web page, rss feed, ajax data or any other “page”.
• Controller: The controller acts as the in between of view and model and, as the name suggests,
  it controls what is sent to the view from the model. In CI, the controller is also the place to load libraries and helpers.

An example of a MVC approach would be for a contact form.

1. The user interacts with the view by filling in a form and submitting it.
2. The controller receives the POST data from the form, the controller sends this data to the model
   which updates in the database.
3. The model then sends the result of the database to the controller.
4. This result is updated in the view and displayed to the user.

This may sound like alot of work to do. But, trust me; when you’re working with a large application, being able to reuse models or views saves a great deal of time.

Step 1: Downloading CodeIgniter

Too start off you will need to download CodeIgniter and upload it to your server. Point your browser
to http://www.codeigniter.com/ and
click the large download button. For this tutorial we are using version 1.70.

Step 2: Installing and Exploring CodeIgniter

Once you have downloaded CodeIgniter, all you need to do is unzip it, and rename the “CodeIgniter_1.7.0″ folder to
either the application name or, in this case, “ci” and upload it to your PHP and MySQL enabled server.
Now that its on your server, I’ll explain what all the folders and files are for:

• The system folder stores all the files which make CI work.
  • The application folder is almost identical to the contents of the system folder
    this is so the user can have files that are particular to that application, for example if a
    user only wanted to load a helper in one application he would place it in the system/application/helpers folder
    instead of the system/helpers folder.
    • The config folder stores all the config files relevant to the application. Which
      includes information on what libaries the application should auto load and database details.
    • The controllers folder stores all the controllers for the application.
    • The errors folder stores all the template error pages for the application. When
      an error occurs the error page is generated from one of these templates.
    • The helpers folder stores all the helpers which are specific to your application.
    • The hooks folder is for hooks which modify the functioning of CI’s core files,
      hooks should only be used by advanced users of CI
    • The language folder stores lines of text which can be loaded through the language
      library to create multilingual sites.
    • The libraries folder stores all the libraries which are specific to your application.
    • The models folder stores all the models for the application.
    • The views folder stores all the views for the application.
  • The cache folder stores all the caches generated by the caching library.
  • The codeigniter folder stores all the internals which make CI work.
  • The database folder stores all the database drivers and class which enable you to
    connect to database.
  • The fonts folder stores all the fonts which can be used by the image manipulation library.
  • The helpers folder stores all of CI’s core helpers but you can place your own helpers
    in here which can be accessed by all of your applications.
  • The language folder stores all of CI’s core language files which its libaries and helpers
    use. You can also put your own language folders which can accessed by all of your applications.
  • The libaries folder stores all of CI’s core libaries but you can place your own libraries
    in here which can be accessed by all of your applications
  • The logs folder stores all of the logs generated by CI.
  • The plugin folder stores all of the plugins which you can use. Plugins are almost identical
    to helpers, plugins are functions intended to be shared by the community.
  • The scaffolding folder stores all the files which make the scaffolding class work.
    Scaffolding provides a convenient CRUD like interface to access information in your database
    during development.
• The user_guide houses the user guide to CI.
• The index.php file is the bit that does all the CI magic it also lets the you change the
  name of the system and application folders.

Step 3: Configuring CodeIgniter

Getting CI up and running is rather simple. Most of it requires you to edit a few configuration
files.

You need to setup CI to point to the right base URL of the app. To do this, open up system/application/config/config.php and
edit the base_url array item to point to your server and CI folder.

$config['base_url'] = "http://localhost/ci/";

Step 4: Testing CodeIgniter

We’ll do a quick test to see if CI is up and running properly. Go to http://localhost/ci/ and you
should see the following.

Step 5: Configuring CodeIgniter Cont.

If you’re up and running, we should finish the configuration. We are starting to configure it specifically for our new helloworld app. If you want to use a database with your application, (which in this tutorial we do.) open up system/application/config/database.php and set the following array items to there corresponding values. This code connects to a MySQL
database called “helloworld” on a localhost with the username “root”, and the password, “root”.

$db['default']['hostname'] = "localhost";
$db['default']['username'] = "root";
$db['default']['password'] = "root";
$db['default']['database'] = "helloworld";
$db['default']['dbdriver'] = "mysql";

Additionally, since we will be using the database quite a bit, we want it to auto load so that we don’t
have to specifically load it each time we connect. Open the system/application/config/autoload.php file
and add ‘database’ to the autoload libaries array.

$autoload['libraries'] = array('database');

Currently, the CI setup will have a default controller called “welcome.php”; you can find this in the system/application/controllers folder. For this tutorial, delete it and open your system/application/config/routes.php file. Change the default array item to point to the “helloworld” controller.

 $route['default_controller'] = "Helloworld"

CI also has a view file that we do not need. Open up the system/application/view/ folder
and delete the welcome_message.php file.

Step 6: Create the Helloworld Database

As this isn’t really a tutorial on MySQL, I’ll keep this section as short as possible. Create a database called “helloworld” and
run the following SQL through phpMyAdmin (or similar MySQL client).

1. CREATE TABLE `data` (
2. `id` int(11) NOT NULL auto_increment,
3. `title` varchar(255) NOT NULL,
4. `text` text NOT NULL,
5. PRIMARY KEY (`id`)
6. ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;
8. INSERT INTO `data` (`id`, `title`, `text`) VALUES(1, ‘Hello World!’, ‘Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla
9. sapien eros, lacinia eu, consectetur vel, dignissim et, massa. Praesent suscipit nunc vitae neque. Duis a ipsum. Nunc a erat. Praesent
10. nec libero. Phasellus lobortis, velit sed pharetra imperdiet, justo ipsum facilisis arcu, in eleifend elit nulla sit amet tellus.
11. Pellentesque molestie dui lacinia nulla. Sed vitae arcu at nisl sodales ultricies. Etiam mi ligula, consequat eget, elementum sed,
12. vulputate in, augue. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae;’);

CREATE TABLE `data` (
  `id` int(11) NOT NULL auto_increment,
  `title` varchar(255) NOT NULL,
  `text` text NOT NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

INSERT INTO `data` (`id`, `title`, `text`) VALUES(1, 'Hello World!', 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla
sapien eros, lacinia eu, consectetur vel, dignissim et, massa. Praesent suscipit nunc vitae neque. Duis a ipsum. Nunc a erat. Praesent
nec libero. Phasellus lobortis, velit sed pharetra imperdiet, justo ipsum facilisis arcu, in eleifend elit nulla sit amet tellus.
Pellentesque molestie dui lacinia nulla. Sed vitae arcu at nisl sodales ultricies. Etiam mi ligula, consequat eget, elementum sed,
vulputate in, augue. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae;');

---

Step 7: Create the Helloworld Model

Models are optional in CI, but it’s considered best practice to use them. They are just PHP classes that contain
functions which work with information from the database. Go
ahead and make a helloworld_model.php file
in the system/application/models folder.
In this file, create a Helloworld_model class, Helloworld_model construct and a function called getData.

In the getData function we are
going to use Active Record database functions which speed up database development times when working
with CI and databases. Essentially, they are simplified functions to create queries.

1. <?php
2. class Helloworld_model extends Model {
4. function Helloworld_model()
5. {
6. // Call the Model constructor
7. parent::Model();
8. }
10. function getData()
11. {
12. //Query the data table for every record and row
13. $query = $this->db->get(‘data’);
15. if ($query->num_rows() > 0)
16. {
17. //show_error(‘Database is empty!’);
18. }else{
19. return $query->result();
20. }
21. }
23. }
24. ?>

<?php
class Helloworld_model extends Model {

    function Helloworld_model()
    {
        // Call the Model constructor
        parent::Model();
    }

    function getData()
		{
			//Query the data table for every record and row
			$query = $this->db->get('data');

			if ($query->num_rows() > 0)
			{
				//show_error('Database is empty!');
			}else{
				return $query->result();
			}
		}

}
?>

---

Step 8: Create the Helloworld Controller

Let’s create a controller that will display the view, and load the model. That way, when
you go to the address http://localhost/ci/index.php/helloworld/, you will see the data from the database.
In the folder system/application/controllers, create a file called helloworld.php.
In this new file, we’ll create a class which has the same name as the file.

Within this class, you need to create a function called “index”. This is the function that will be
displayed when no other is provided – e.g. when http://localhost/ci/index.php/helloworld/ is
visited. If, for example, we created a function called foo, we could find this as http://localhost/ci/index.php/helloworld/foo/.

The key thing to remember is how CI structures its URLs; e.g http://host/codeignitordirectory/index.php/class/function.

In the controller index function, we need to load the model, query the database, and pass this queried
data to the view. To load any resources into CI e.g. libraries,
helpers, views, or, models, we use the load class. After we have loaded the model, we can access it through
its model name and the particular function. To pass data to a view we need to assign it to an array
item and pass the array – which recreates the array items as a variable in the view file.

1. <?php
2. class Helloworld extends Controller{
3. function index()
4. {
5. $this->load->model(‘helloworld_model’);
7. $data['result'] = $this->helloworld_model-><span class=”sql”>getData</span>();
8. $data['page_title'] = “CI Hello World App!”;
10. $this->load->view(‘helloworld_view’,$data);
11. }
12. }
13. ?>

<?php
	class Helloworld extends Controller{
		function index()
		{
			$this->load->model('helloworld_model');

			$data['result'] = $this->helloworld_model->getData();
			$data['page_title'] = "CI Hello World App!";

			$this->load->view('helloworld_view',$data);
	    }
	}
?>

If we visited http://localhost/ci/index.php/helloworld/ now, it wouldn’t work; this is because the view file does not exist.

---

Step 9: Create the Helloworld View

The view file is what the user sees and interacts with, it could be a segment of a page, or the whole page. You can pass an array of variables to the view through the second argument
of the load model function. To make the view for our tutorial, create a new file called helloworld_view.php in the system/application/view folder. Next, we just need to create our normal html, head
and body elements, and then a header and paragraph for the information from the database. To display all
the records received from the database, we put it in a “foreach” loop
which loops through all the elements.

1. <html>
2. <head>
3. <title><?=$page_title?></title>
4. </head>
5. <body>
6. <?php foreach($result as $row):?>
7. <h3><?=$row->title?></h3>
8. <p><?=$row->text?></p>
9. <br />
10. <?php endforeach;?>
11. </body>
12. </html>

<html>
	<head>
		<title><?=$page_title?></title>
	</head>
	<body>
		<?php foreach($result as $row):?>
		<h3><?=$row->title?></h3>
		<p><?=$row->text?></p>
		<br />
		<?php endforeach;?>
	</body>
</html>

You may have noticed that we are using php alternative syntax, this provides an convenient and time
saving way to write echo statements.

---

Step 10: Ta-da and Some Extras

When you visit “http://localhost/ci/index.php/helloworld/”, you
should see something similar to this.

But we aren’t done yet. There are a few things you can do to improve your CodeIgniter experience -
like removing that annoying index.php bit out of the URL. You can accomplish this task by creating a .htaccess file in the root folder, and adding the following code.

RewriteEngine on
RewriteCond $1 !^(index\.php|images|robots\.txt)
RewriteRule ^(.*)$ ci/index.php/$1 [L]

You’ll also need to open up the config.php file in system/application/config/ and edit the index_page array item to a blank string.

1. $config['index_page'] = “”;

$config['index_page'] = "";

Another nifty trick is to turn on CI’s ability to parse PHP alternative syntax if its
not enabled by the server. To do this, open up the same file as before, system/application/config/config.php, and set the rewrite_short_tags array item to TRUE.

1. $config['rewrite_short_tags'] = TRUE;

$config['rewrite_short_tags'] = TRUE;

]]> http://freelance-php-developer.phpmysql.co.za/2010/06/php-developer-codeigniter-mvc-framework/feed/ 0 http://freelance-php-developer.phpmysql.co.za/2010/06/what-is-mvc/ http://freelance-php-developer.phpmysql.co.za/2010/06/what-is-mvc/#comments Sun, 13 Jun 2010 15:55:42 +0000 admin http://freelance-php-developer.phpmysql.co.za/?p=77

Model View Controller MVC

MVC is a design pattern. A Design pattern is a code structure that allows for common coding frameworks to be replicated quickly. You might think of a design pattern as a skeleton or framework on which your application will be built.

In the MVC framework that is created in this tutorial, several key points will be raised. The first is the frameworks needs a single point of entry, ie: index.php. This is where all access to the site must be controlled from. To ensure that a single point of entry is maintained, htaccess can be utilized to ensure no other file may be accessed, and that we hide the index.php file in the url. Thus creating SEO and user friendly URL’s.

It is beyond the scope of this tutorial to show how to set up htaccess and mod_rewrite and more information on these can be gained from the Apache manual. The .htaccess file itself looks like this.

RewriteEngine on

RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d

RewriteRule ^(.*)$ index.php?rt=$1 [L,QSA]

The .htaccess file will permit access to the site via urls such as

http://www.example.com/news/show

If you do not have mod_rewrite available, the entry to the site will be the same, except that the URL will contain the values needed such as:

http://www.example.com/index.php?rt=news/show

]]> http://freelance-php-developer.phpmysql.co.za/2010/06/what-is-mvc/feed/ 0 http://freelance-php-developer.phpmysql.co.za/2010/03/php-freelancer-retrieving-data-in-a-range-by-sql-between/ http://freelance-php-developer.phpmysql.co.za/2010/03/php-freelancer-retrieving-data-in-a-range-by-sql-between/#comments Sun, 28 Mar 2010 10:12:32 +0000 admin http://freelance-php-developer.phpmysql.co.za/?p=70

Working with Database

Create a database with a specified name if it does not exist in database server

CREATE DATABASE [IF NOT EXISTS] database_name

Use database or change current database to another database you are working with

USE database_name

Drop a database with specified name permanently. All physical file associated with the database is no longer exists.

DROP DATABASE [IF EXISTS] database_name

Show all available databases in database server

SHOW DATABASES

Working with Table

Lists all tables in a database.

SHOW TABLES

Create table statement defines the structure of table in a database.

 CREATE [TEMPORARY] TABLE [IF NOT EXISTS] table_name
 (create_clause ,...) [table_options]
 [[IGNORE|REPLACE] select]

Altering table structure

ALTER [IGNORE] TABLE table_name actions

Actions can be one of the following actions:

ADD [COLUMN]

Add a new column into a table

DROP [COLUMN]

Drop an existing column in a table

ADD INDEX [name](column_name, ...)

Add index with a specific name to a table on a column

DROP INDEX index_name Drop an index from a table

ADD PRIMARY KEY (column_name,…)

Add primary key into a tables

DROP PRIMARY KEY

Drop primary key from a table

Deleting table permanently

 DROP TABLE [IF EXISTS] table_name [, name2, ...]
 [RESTRICT | CASCADE]

Give information about the table or column.

DESCRIBE table [column_name]
DESC table [column_name]
 

Working with Index

Creating an index with the specified name on a table

CREATE [UNIQUE|FULLTEXT] INDEX index_name
ON table (column_name,...)

Removing a specified index from table

DROP INDEX index_name

Retrieving Data

Retrieving complete data in a database table

SELECT * FROM table_name

Retrieving specified data which is shown in the column list from a database table

SELECT column_name, column_name2….
FROM table_name

Retrieving unique records

SELECT DISTINCT (column_name)
FROM table_name

Retrieving data from multiples table using join

SELECT *
FROM table_name1
INNER JOIN table_name2 ON conditions

SELECT *
FROM table_name1
LEFT JOIN table_name2 ON conditions

SELECT *
FROM table_name1
RIGHT JOIN table_name2 ON conditions

Counting number of rows in a database table

SELECT COUNT (*)
FROM table_name

Sorting ascending or descending retrieved data based on one or more column

SELECT column_name, column_name2….
FROM table_name
ORDER BY column_name ASC [DESC], column_name2 ASC [DESC],

Group the retrieved rows data

SELECT *
FROM table_name
GROUP BY column_name

Matching Data based on a pattern

Matching data using LIKE operator

SELECT * FROM table_name
WHERE column_name LIKE ‘%value%’

Matching data using regular expression

SELECT * FROM table_name
WHERE column_name RLIKE ‘regular_expression’



 

 

Mark
 BSc Honours in Computer Science
 Software Architect / Developer
 Mobile 079 9111 855

Email info@mydeveloper.co.za

SQL UNION allows you to combine two or more result sets from select statements into a single result set. The usage of using SQL UNION is as follows:

SELECT statement
UNION [DISTINCT | ALL]
SELECT statement
UNION [DISTINCT | ALL]

…
The column list of each individual SELECT statement must have the same data type. By default the UNION removes all duplicated rows from the result set even if you don’t explicit using DISTINCT after the UNION keyword. If you use UNION ALL explicitly, the duplicated rows will remain in the result set. Let’s practice with couples of examples which use SQL UNION. Suppose you want to combine customers and employees into one, you just perform the following query:

SELECT customerNumber id, contactLastname name
FROM customers
UNION
SELECT employeeNumber id,firstname name
FROM employees

Here is the excerpt of the output

    id  name
------  ---------------
   103  Schmitt
   112  King
   114  Ferguson
   119  Labrune
   121  Bergulfsen
   124  Nelson
   125  Piestrzeniewicz
   128  Keitel
   129  Murphy
   131  Lee

In order to use ORDER BY to sort the result you have to use it after the last SELECT statement. It would be the best to parenthesize all the SELECT statements and place ORDER BY after the last one. Suppose we use the want to sort the combination of employees and customers in the query above we can do as follows:

(SELECT customerNumber id,contactLastname name
FROM customers)
UNION
(SELECT employeeNumber id,firstname name
FROM employees)
ORDER BY name,id

First it orders the result set by name and then by id What if we don’t use alias for each column in the SELECT statement? MySQL uses the column names in the first SELECT statement as the label of the result therefore you can rewrite the query above as follows:

(SELECT customerNumber, contactLastname
FROM customers)
UNION
(SELECT employeeNumber, firstname
FROM employees)
ORDER BY contactLastname, customerNumber

or you can also use the column position in the ORDER BY clause like following query

(SELECT customerNumber, contactLastname
FROM customers)
UNION
(SELECT employeeNumber,firstname
FROM employees)
ORDER BY 2, 1

In the real database programming task, you usually does not select data from just one table because of the normalization process (a big table is divided into a subset of smaller tables). So to get the complete data, you need to use SQL JOIN clause in SELECT statement. The normal form of SQL JOIN clause in MySQL is simple follows:

 SELECT column_list FROM table_1
 [INNER | LEFT | RIGHT] table_2 ON conditions_2
 [INNER | LEFT | RIGHT] table_3 ON conditions_3 ...
 WHERE conditions

After SELECT keyword is a list of column name in which you want to retrieve the data. These columns have to be in the tables you select such as table_1, table_2… If the columns’ name in those tables are the same, you have to explicit declare the as the form table_name.column_name, otherwise MySQL will returns you an error message to say that the column name you selected is ambiguous. Next you will list the main table and then a list of table you want to join. You can use INNER JOIN, LEFT JOIN or RIGHT JOIN. You can join a table with more than twotables or even with itself. In the JOIN clause you have to declare the join conditions. If all the conditions on each join clause match, MySQL will return the corresponding data.

Using INNER JOIN

INNER JOIN is used to retrieve the data from all tables listed based on condition listed after keyword ON. If the condition is not meet, nothing is returned. For example, see the followingtables in our classicmodels sample database. We have employees table and offices table. Two tables are linked together by the column officeCode. To find out who is in which country and state we can use INNER JOIN to join these tables. Here is the SQL code:

SELECT employees.firstname,
       employees.lastname,
       offices.country,
       offices.state
FROM employees
INNER JOIN offices
  ON offices.officeCode = employees.officeCode

And we will get the data like this:

+-----------+-----------+-----------+------------+
| firstname | lastname  | country   | state      |
+-----------+-----------+-----------+------------+
| Diane     | Murphy    | USA       | CA         |
| Mary      | Patterson | USA       | CA         |
| Jeff      | Firrelli  | USA       | CA         |
| William   | Patterson | Australia | NULL       |
| Gerard    | Bondur    | France    | NULL       |
| Anthony   | Bow       | USA       | CA         |
| Leslie    | Jennings  | USA       | CA         |
| Leslie    | Thompson  | USA       | CA         |
| Julie     | Firrelli  | USA       | MA         |
| Steve     | Patterson | USA       | MA         |
| Foon Yue  | Tseng     | USA       | NY         |
| George    | Vanauf    | USA       | NY         |
| Loui      | Bondur    | France    | NULL       |
| Gerard    | Hernandez | France    | NULL       |
| Pamela    | Castillo  | France    | NULL       |
| Larry     | Bott      | UK        | NULL       |
| Barry     | Jones     | UK        | NULL       |
| Andy      | Fixter    | Australia | NULL       |
| Peter     | Marsh     | Australia | NULL       |
| Tom       | King      | Australia | NULL       |
| Mami      | Nishi     | Japan     | Chiyoda-Ku |
| Yoshimi   | Kato      | Japan     | Chiyoda-Ku |
| Martin    | Gerard    | France    | NULL       |
+-----------+-----------+-----------+------------+
23 rows in set (0.02 sec)

If you want to find only employees in USA, just execute this query:

SELECT e.firstname,
       e.lastname,
       state
FROM employees e
INNER JOIN offices p
  ON o.officeCode = e.officeCode AND country = 'USA'

Here is the data back

+-----------+-----------+-------+
| firstname | lastname  | state |
+-----------+-----------+-------+
| Diane     | Murphy    | CA    |
| Mary      | Patterson | CA    |
| Jeff      | Firrelli  | CA    |
| Anthony   | Bow       | CA    |
| Leslie    | Jennings  | CA    |
| Leslie    | Thompson  | CA    |
| Julie     | Firrelli  | MA    |
| Steve     | Patterson | MA    |
| Foon Yue  | Tseng     | NY    |
| George    | Vanauf    | NY    |
+-----------+-----------+-------+
10 rows in set (0.00 sec)

Using LEFT and RIGHT JOIN

LEFT JOIN can be used when you want to retrieve the data from the main table (table1) even if there is no match in other tables (table_2, table_3….). While RIGHT JOIN is used to retrieve the data the from all other tables (table_2, table_3…) even if there is no match in the main table. As an example, in our classicalmodels sample database, when the company want to establish a new office, the SQL script to insert a new office to the databse as follows:

INSERT INTO classicmodels.offices
	(officeCode,
         city,
         phone,
         addressLine1,
         addressLine2,
	 state,
	 country,
	 postalCode,
	 territory
	)
VALUES  ('8',
        'Boston',
        '+1 215 837 0825',
        '1550 dummy street',
         'dummy address',
	'MA',
	'USA',
	'02107',
	'NA'
	)

At this time, the company hasn’t any hire new employee yet so the new office does not have any employee. If we want to know employee who belongs to which office and all the offices of the company, we can use RIGHT JOIN as follows:

 SELECT firstname,
        lastname,
 addressLine1
 FROM employees e
 RIGHT JOIN offices o ON o.officeCode = e.officeCode

+-----------+-----------+--------------------------+
| firstname | lastname  | addressLine1             |
+-----------+-----------+--------------------------+
| Mary      | Patterson | 100 Market Street        |
| Diane     | Murphy    | 100 Market Street        |
| Jeff      | Firrelli  | 100 Market Street        |
| Anthony   | Bow       | 100 Market Street        |
| Leslie    | Jennings  | 100 Market Street        |
| Leslie    | Thompson  | 100 Market Street        |
| Julie     | Firrelli  | 1550 Court Place         |
| Steve     | Patterson | 1550 Court Place         |
| Foon Yue  | Tseng     | 523 East 53rd Street     |
| George    | Vanauf    | 523 East 53rd Street     |
| Gerard    | Bondur    | 43 Rue Jouffroy D'abbans |
| Loui      | Bondur    | 43 Rue Jouffroy D'abbans |
| Gerard    | Hernandez | 43 Rue Jouffroy D'abbans |
| Pamela    | Castillo  | 43 Rue Jouffroy D'abbans |
| Martin    | Gerard    | 43 Rue Jouffroy D'abbans |
| Mami      | Nishi     | 4-1 Kioicho              |
| Yoshimi   | Kato      | 4-1 Kioicho              |
| William   | Patterson | 5-11 Wentworth Avenue    |
| Andy      | Fixter    | 5-11 Wentworth Avenue    |
| Peter     | Marsh     | 5-11 Wentworth Avenue    |
| Tom       | King      | 5-11 Wentworth Avenue    |
| Larry     | Bott      | 25 Old Broad Street      |
| Barry     | Jones     | 25 Old Broad Street      |
| NULL      | NULL      | 1550 dummy street        |
+-----------+-----------+--------------------------+
24 rows in set (0.00 sec)

As you can see, the RIGHT JOIN get the all the data from second table (offices) and data from the first table even the conditiondoes not match.

Joining a Table to Itself or Self joins

You can also using JOIN clause to join table to itself. Consider the following situation to our sample databse, we want to know who has to report to whom in organization structure. Here is the SQL script:

SELECT concat(e.firstname,',',e.lastname) AS employee,
       concat(m.firstname,',',m.lastname) AS manager
FROM employees AS m
INNER JOIN employees AS e ON m.employeeNumber  = e.reportsTo
ORDER BY employee

+------------------+-------------------+
| employee         | manager           |
+------------------+-------------------+
| Andy,Fixter      | William,Patterson |
| Barry,Jones      | Gerard,Bondur     |
| Foon Yue,Tseng   | Anthony,Bow       |
| George,Vanauf    | Anthony,Bow       |
| Gerard,Hernandez | Gerard,Bondur     |
| Jeff,Firrelli    | Diane,Murphy      |
| Julie,Firrelli   | Anthony,Bow       |
| Larry,Bott       | Gerard,Bondur     |
| Leslie,Jennings  | Anthony,Bow       |
| Leslie,Thompson  | Anthony,Bow       |
| Loui,Bondur      | Gerard,Bondur     |
| Martin,Gerard    | Gerard,Bondur     |
| Mary,Patterson   | Diane,Murphy      |
| Pamela,Castillo  | Gerard,Bondur     |
| Peter,Marsh      | William,Patterson |
| Steve,Patterson  | Anthony,Bow       |
| Tom,King         | William,Patterson |
| Yoshimi,Kato     | Mami,Nishi        |
+------------------+-------------------+