as promised, orchid comes with real flexibility which lets you design your application in less time. in orchid, there is a nice active record object which helps you to interact with your database very easily. beside that, you can also write your own model class to facilitate comples business logics and operations. in this installment, we will learn how to achieve maximum speed and benefit by using the builtin model library of orchid with a toppings of the active record library.

2.1 connecting to a database

the built in data access libraries in orchid will help you to connect to mysql, postgresql, mssqlserver and sqlite in a minute. beside that you can also connect to other database engines by using native wrapper of pdo. all you have to do is to add a few lines in the configuration file and whoa, you are connected. don’t you believe me? lets see

create a file named configs.php in app/config/configs.php with the following contents

$configs['db']['production']['dbname']="";
$configs['db']['production']['dbhost']="";
$configs['db']['production']['dbuser']="";
$configs['db']['production']['dbpwd']="";
$configs['db']['production']['persistent']="";
$configs['db']['production']['dbtype']="";


in orchid you can have as many database state (such as production, development or whatever) as you want. in the example above, we named our db state as “production”. rest of the code is self explanatory, right? the only confusion you might have is about “persistent”. well, if you set it to true, the connection to your database stay alive as long as you are using the same connection strings, which will save some microseconds from connecting every time your script executes.

you are not done yet. there are some more configuration directives we have to add. we haven’t yet specified the type of our database and which db state orchid will use, lets do that. add the following two lines in your configs.php


$configs['db']['usedb']=""; //true or false
$configs['db']['state']="development";


the value of “usedb” could be either one of “mysql”,”mysqli”,”pgsql”,”mssql”,”pdo” or “sqlite”. and using usedb you can tell orchid to use database engines or not. so you can save the connection parameters for use later by specifying the “usedb” parameter to “false”.

ding dong! you are connected to your favorite db engine in a minute, as said.

2.2 good coding and bad coding while working with database

in orchid (and in most other framework possibly) you can directly use the internal dbmanager to execute sql, fetch the result and manipulate that through out your application. i have seen developers manipulating records in controllers, in views and skipped the most appropriate part where these manipulation should take part in fact, models. many of you dont make use of the models in your application and write the business logic entirely in your controller, feeding the inner monster of your application to be the most vigorous unmanageable giant. dont blame php as a tool to write unmanageable code because this unmanageable code solely depends on you – you. always try to use models to encapsulate the business logic and separate it from your controller. lets model do it’s job.

2.3 working with models

in this section we will write a simple model and insert some data inside a table. here comes the schema of the table.

CREATE TABLE `comics` (
  `id` int(11) NOT NULL auto_increment,
  `comicname` varchar(255) default NULL,
  `comicurl` varchar(255) default NULL,
  PRIMARY KEY  (`id`)
)

in orchid, you can instantly create a reference to any table in your database by auto model feature of orchid, which looks like the code below, which will reside in a controller.


$comicsmocdel = $this->model->comics;


orchid will dynmically create a reference of the “comics” table instantly, no more hassle for you. but there are significant causes why we will write models by coding it. the auto models support only the very basic data manipulation. if you want to encapsulate business logic inside, we definitely need to write the code inside. lets learn first how to work with a auto model like this one.

a model in orchid supports the following methods

• selecting data
• basic joining
• insert
• delete
• update
• finding based on criteria

as we have already created a model, lets make use of it. the following piece of code will insert a record in the comics table using the model.


$comicsmodel = $this->model->comics;
$comicsmodel->comicname = "Nancy and Sluggo";
$comicsmodel->comicurl = "http://comics.com/comics/nancy/index.html";
$comicsmodel->insert();


this is really simple to work with models in orchid, like as i said, the above example will insert a data in your data table named “comics”. now lets see how we can modify the existing data. in the following example we will change the name of the comic to the data which we’d just inserted.


//inside the controller action
$comicsmodel = $this->model->comics;
$data = $comicsmodel->find("comicname = 'Nancy and Sluggo'");
print_r($data);
if(!empty($data))
{
$comicsmodel->comicname="Nancy & Sluggo";
$comicsmodel->update();
}


the find method can take any clause and find records according to that. similarly as update and insert, you can delete records using models in orchid.

in upcoming tutorials we will learn more on models and encapsulating business logic by writing in by our own 🙂

today i was planning to start the documentation of orchid framework for the rest of us(?). so this one is the first installment of this series. you will find small tutorials everyday. just stick with the series and you will see how far we can fly you. time to get high 🙂 [please note that the text in this series will be all-small cap]

getting started with orchid

orchid is a small framework with bare necessities to kick start developing killer php web applications. this framework is not flooded with unnecessary features and libraries. it only contains the essential helpers and libraries to boost up your development, not slowing it down. orchid features a very short learning curve, which will keep you trouble free. small footprint and excellent profile will be your first choice, which you will definitely realize once you start realizing the power that orchid brings in your hand. long story short, orchid is the next framework going to rock.

you can checkout orchid from it’s subversion repository
svn checkout http://orchidframework.googlecode.com/svn/trunk/ orchidframework

orchid comes pre equipped with excellent configuration directives in a config file, which we will focus in details in the upcoming tutorials. for now lets just start as is.

to create your first application, we need to create a folder named “app” inside the orchidframework directory. after you create that, there will be three directories named app, core and tests.

in orchid, controllers reside in app/controllers directory. views (templates) reside in app/views/controller_name/ directory, which means if the name of your controller is “blog”, all your views remains in app/views/blog/ directory. lets create our first controller named “talk”. the controller file will be app/controllers/talk.php.

a controller in orchid is a normal php class file which extends the base controller class. all the public methods in a controller class are considered as action. a method named “base” is the primary action for all the controller in orchid. and for now, this is all the information you need to create your first controller in orchid.

lets write a sample action in our controller, named “base”

<?php
/**
 * the source file is app/controllers/talk.php
 */
class talk extends controller
{
	public function base()
	{
		echo "hello";
	}
}
?>

now you can see this controller in action by pointing your browser to the following location. i’ve considered that you hosted orchid in your document root (i.e /var/www/orchid)

http://localhost/orchid/talk

whoops, what have we done wrong? why do we get an error?

we are seeing this error because we didnt write our view (or template, whatever you call it) yet. and this is not a good coding practice to output anthing directly from your controller. whatever the size of the output, you should display it by passing the data to a view first. this will ensure the consistency of your project through out the application. orchid is flexible, but keeping the word “flexibility with responsibility”

lets write the view file, named “<i>base.php</i>” which will reside in app/views/talk/ directory.

<?//the source file is app/views/talk/base.php?>
<?=$talkings;?>

so where from do we get the variable named $talkings? dont worry, you will have to pass it to the view from your controller. in fact through out your application you have to pass all the data to a view from the controller in almost every mvc framework and orchid is not the exception in this case. lets re write the controller

<?php
/**
 * the source file is app/controllers/talk.php
 */
class talk extends controller
{
	public function base()
	{
		$this->setViewParam("talkings","hello world");
	}
}
?>

now you will see the output “hello world” as output when you point your browser to http://localhost/orchid/talk

orchid is very flexible and if you need to raw output (for example after a ajax request) some content from your controller, you can even do that. orchid wont restrict you from not doing so, but what we really said is that for good coding you should follow this guideline.

so that’s it. getting started in orchid wont take more than 5 minutes and that is where the blessings of using a framework is in. in next tutorial we will learn how to use a model in orchid.