Performance Class

LavaLust has a Performance class that is always active, enabling the time difference between any two marked points to be calculated.

Using the Performance Class

The Performance class can be used within your controllers , views, or your models. The process for usage is this:

1. Mark a start point
2. Mark an end point
3. Run the “elapsed time” function to view the results

Here’s an example using real code:

								
$this->performance->start('referrence_name');

// Some code happens here

$this->performance->stop('referrence_name');
echo $this->performance->elapsed_time('referrence_name');
								
							

										
$this->performance->start('dog');

// Some code happens here

$this->performance->start('cat');

// More code happens here

$this->performance->stop('cat');

$this->performance->start('bird');

// More code happens here

$this->performance->stop('bird');

$this->performance->stop('dog');

echo $this->performance->elapsed_time('dog');
echo $this->performance->elapsed_time('cat');
echo $this->performance->elapsed_time('bird');
										
									

Displaying Total Execution Time

If you would like to display the total elapsed time from the moment LavaLust starts to the moment the final output is sent to the browser, simply place this in one of your view templates:

								
<?php echo $this->performance->elapsed_time();?>
								
							

Displaying Memory Consumption

If your PHP installation is configured with –enable-memory-limit, you can display the amount of memory consumed by the entire system using the following code in one of your view file:

								
<?php echo $this->performance->memory_usage();?>
								
							

Cache Class

LavaLust provide a simple caching system that can boost the performance of your application.

You can cache liraries or models and other object or array data. You need first to load Cache library by calling $this->call->library('cache').

You ca specify the cache folder by changing the configuration set in app/config/config.php file.

								
$config['cache_dir'] = 'runtime/cache/';
								
							

Example: Caching a model

								
$this->cache->model('news_model', 'get_news', array($param1, $param2), 120);
								
							

In the example above let say we have news_model class with get_news() method and two parameters: $param1 and $param2. get_news() method will be cached for 120 minutes as set as the 4th parameter in the example.

Example: Caching a library

								
$this->cache->library('some_library', 'calculate_something', array($foo, $bar, $bla));
								
							

In the example above let say we have some_library class with calculate_something() method and three parameters: $foo, $bar and $bar. calculate_something() method will be cached for unlimited time if you do not specify it in the 4th parameter. This is also applicable in caching model.

Example: Caching a array or object

								
$data = array(
	'id' => 1,
	'username' => 'acidcore'
	);
//Storing the data in a cache with a name "cached_name"
$this->cache->write($data, 'cached_name');

//Retrieving a cache based on its name "cached_name"
$data = $this->cache->get('cached_name');
								
							

Example: Delete specific cache by its name.

								
$this->cache->delete('cached_name');
								
							

In the example above, it will find and delete a cache inside cached folder based on its name "cached_name".

Example: Delete all cache

								
$this->cache->delete_all();
								
							

In the example above, it will delete all stored cache inside the cache direcotry.

Example: Delete cache based on cache group

								
$this->cache->write($data, 'nav_header');
$this->cache->write($data, 'nav_footer');
$this->cache->delete_group('nav_');
								
							

In the example above, it will find and delete a cache with the prefix nav_ inside cached folder.

Example: Delete cache from library or model

								
$this->cache->model('news', 'get_news', array($param1, $param2), -1);
								
							

In the example above, the cache version of the method get_news of news model will be deleted inside the cache directory. This will be the same if you'll use this in library classes.

Email Class

Sending email is simple and easy to do. It only uses built-in mail() function of PHP. If you are planning to use more advanced features, you can use PHPMailer library.

Here is a basic example demonstrating how you might send email. Note: This example assumes you are sending the email from one of your controllers.

								
$this->call->library('email');

$this->email->sender('your@example.com', 'Your Name');
$this->email->recipient('someone@example.com');

$this->email->subject('Email Test');
$this->email->email_content('Testing the email class.');

$this->email->send();
								
							

Here are the complete list of methods that can be used in sending email.

Form Validation Class

Before explaining LavaLust's approach to data validation, let’s describe the ideal scenario:

1. A form is displayed.
2. You fill it in and submit it.
3. If you submitted something invalid, or perhaps missed a required item, the form is redisplayed containing your data along with an error message describing the problem.
4. This process continues until you have submitted a valid form.

On the receiving end, the script must:

1. Check for required data.
2. Verify that the data is of the correct type, and meets the correct criteria. For example, if a username is submitted it must be validated to contain only permitted characters. It must be of a minimum length, and not exceed a maximum length. The username can’t be someone else’s existing username, or perhaps even a reserved word. Etc.
3. Sanitize the data for security.
4. Pre-format the data if needed (Does the data need to be trimmed? HTML encoded? Etc.)
5. Prep the data for insertion in the database.

Although there is nothing terribly complex about the above process, it usually requires a significant amount of code, and to display error messages, various control structures are usually placed within the form HTML. Form validation, while simple to create, is generally very messy and tedious to implement.

Form Validation Tutorial

In order to implement form validation you’ll need three things:

1. A View file containing a form.
2. A View file containing a “success” message to be displayed upon successful submission.
3. A controller method to receive and process the submitted data.

The Form

								
<html>
<head>
<title>My Form</title>
</head>
<body>
<?php $LAVA = lava_instance(); ?>
<?php echo $LAVA->form_validation->errors(); ?>
<form action="<?php echo site_url('form');?>" method="post">
<h5>Username</h5>
<input type="text" name="username" value="" size="50" />
<h5>Password</h5>
<input type="text" name="password" value="" size="50" />

<h5>Password Confirm</h5>
<input type="text" name="passconf" value="" size="50" />

<h5>Email Address</h5>
<input type="text" name="email" value="" size="50" />

<div><input type="submit" value="Submit" /></div>

</form>

</body>
</html>
								
							

The Success Page

Using a text editor, create a form called formsuccess.php. In it, place this code and save it to your app/views/ folder:

								
<html>
<head>
<title>My Form</title>
</head>
<body>

<h3>Your form was successfully submitted!</h3>

</body>
</html>
								
							

The Controller

Using a text editor, create a controller called Form.php. In it, place this code and save it to your app/controllers/ folder:

								
<?php

class Form extends Controller {

	public function index()
	{
		$this->call->library('form_validation');

		if ($this->form_validation->run() == FALSE)
		{
			$this->call->view('myform');
		}
		else
		{
			$this->call->view('formsuccess');
		}
	}
}
								
							

Try it!

To try your form, visit your site using a URL similar to this one:

								
example.com/index.php/form/
								
							

If you submit the form you should simply see the form reload. That’s because you haven’t set up any validation rules yet.

Since you haven’t told the Form Validation class to validate anything yet, it returns FALSE (boolean false) by default. ``The run()`` method only returns TRUE if it has successfully applied your rules without any of them failing.

Explanation

You’ll notice several things about the above pages:

The form (myform.php) is a standard web form with a couple exceptions:

1. It uses a form helper to create the form opening. Technically, this isn’t necessary. You could create the form using standard HTML. However, the benefit of using the helper is that it generates the action URL for you, based on the URL in your config file. This makes your application more portable in the event your URLs change.
2. At the top of the form you’ll notice the following function call:

									
<?php echo $this->form_validation->errors(); ?>
									
								

This function will return any error messages sent back by the validator. If there are no messages it returns an empty string.

The controller (Form.php) has one method: index(). This method runs the validation routine. Based on whether the validation was successful it either presents the form or the success page.

Setting Validation Rules

Let us take a look at our controller above. There are no validation rules set so we will try to use some of the common validation methods.

								
<?php

class Form extends Controller {

public function index()
{
	$this->call->library('form_validation');
	$this->form_validation
		->name('username')
			->required()
			->min_length(5)
			->max_length(20)
		->name('password')
			->required()
			->min_length(8)
		->name('passconf')
			->matches('password')
			->required()
			->min_length(8)
		->name('email')
			->valid_email();
	if ($this->form_validation->run() == FALSE)
	{
		$this->call->view('myform');
	}
	else
	{
		$this->call->view('formsuccess');
	}
}
}
								
							

In the above code, we use name() method to get the input to validate. You should use the exact name you’ve given the form field. required(), min_length(), max_length(), matches() and valid_email() are all validation methods. There is an optional parameter for each methods that is used to add custom error message.

Here are the complete list of methods that can be used in form validation.

Upload Class

LavaLust's File Uploading Class permits files to be uploaded. You can set various preferences, restricting the type and size of the files.

The Process

Uploading a file involves the following general process:

• An upload form is displayed, allowing a user to select a file and upload it.
• When the form is submitted, the file is uploaded to the destination you specify.
• Along the way, the file is validated to make sure it is allowed to be uploaded based on the preferences you set.
• Once uploaded, the user will be shown a success message.

To demonstrate this process here is brief tutorial. Afterward you’ll find reference information.

Creating the Upload Form

Using a text editor, create a form called upload_form.php. In it, place this code and save it to your app/views/ directory:

								
<html>
<head>
<title>Upload Form</title>
</head>
<body>

<?php foreach($errors as $error) { echo $error; };?>

<form action="<?php echo site_url('upload/do_upload');?>" method="post" enctype="multipart/form-data"></form>

<input type="file" name="userfile" size="20" />

<br /><br />

<input type="submit" value="upload" />

</form>

</body>
</html>
								
							

You’ll notice we are using a form helper to create the opening form tag. File uploads require a multipart form, so the helper creates the proper syntax for you. You’ll also notice we have an $error variable. This is so we can show error messages in the event the user does something wrong.

The Success Page

Using a text editor, create a form called upload_success.php. In it, place this code and save it to your app/views/ directory:

								
<html>
<head>
<title>Upload Form</title>
</head>
<body>

<h3>Your file was successfully uploaded!</h3>

<?php echo $filename;?>

</body>
</html>
								
							

The Controller

Using a text editor, create a controller called Upload.php. In it, place this code and save it to your app/controllers/ directory:

								
class Upload extends Controller {

	public function upload() {
		$this->call->library('upload', $_FILES["userfile"]);
		$this->upload
			->max_size(5)
			->min_size(1)
			->set_dir('public')
			->allowed_extensions(array('jpg'))
			->allowed_mimes(array('image/jpeg'))
			->is_image()
			->encrypt_name();
		if($this->upload->do_upload()) {
			$data['filename'] = $this->upload->get_filename();
			$this->call->view('upload_form', $data);
		} else {
			$data['errors'] = $this->upload->get_errors();
			$this->call->view('upload_form', $data);
		}
	}
}
								
							

The Upload Directory

You’ll need a destination directory for your uploaded images. Create a directory at the root of your LavaLust installation called uploads and set its file permissions to 777.

Reference Guide

Like most other classes in LavaLust, the Upload class is initialized in your controller using the $this->call->library() method:

								
$this->call->library('upload');
								
							

Once the Upload class is loaded, the object will be available using: $this->upload

Setting Preferences

Similar to other libraries, you’ll control what is allowed to be upload based on your preferences. In the controller you built above you set the following preferences:

								
$this->call->library('upload', $_FILES["userfile"]);
$this->upload
	->max_size(5)
	->min_size(1)
	->set_dir('public')
	->allowed_extensions(array('jpg'))
	->allowed_mimes(array('image/jpeg'))
	->is_image()
	->encrypt_name();
								
							

The above preferences should be fairly self-explanatory. Below is a table describing all available preferences.

Preferences

The following preferences are available. The default value indicates what will be used if you do not specify that preference.

Language Class

The Language Class provides functions to retrieve language files and lines of text for purposes of internationalization.

In your LavaLust scheme folder, you will find a language sub-directory containing a sample file for the english idiom. (en-US)

								
return array(
	/**
	* Pagination
	*/
	'first_link' => '‹ First',
	'next_link' => '>',
	'prev_link' => '<',
	'last_link' => 'Last ›',
	'page_delimiter' => '/?page=',//if query string is enabled in your config, you can use something like `/?page=` to this
	'classes' => array('nav' => '', 'ul' => 'pagination', 'li' => 'page-item', 'a' => 'page-link'),//default for bootstrap 4. You can change the value according to your choice.

	/**
	* Other String to be translated here
	*/
	'welcome' => 'Hello {username} {type}',
								
							

As you can see, there are default keys with value in english language. If you want to add language file and alter the values of each keys, you need to use two functions under language helper. lang() and language()

You can add language file inside app/language folder. For example you will add tl-PH.php and you will alter some values if selected as default language.

							
return array(
/**
* Pagination
*/
'first_link' => '‹ Una',
'next_link' => '>',
'prev_link' => '<',
'last_link' => 'Huli ›',
'page_delimiter' => '/?page=',//if query string is enabled in your config, you can use something like `/?page=` to this
'classes' => array('nav' => '', 'ul' => 'pagination', 'li' => 'page-item', 'a' => 'page-link'),//default for bootstrap 4. You can change the value according to your choice.

/**
* Other String to be translated here
*/
'welcome' => 'Hello {username} {type}',
							
						

To use it as default language, you can call language helper and use the said two functions above.

							
$this->call->helper('language');
language('tl-PH');
lang('first_link');
lang('last_link');
							
						

In the example, you will see "‹ Una" and "Huli › instead of the "‹ First" and "Last ›" because you chose tl-PH upon using language() function.

Session Library

The Session class permits you maintain a user’s “state” and track their activity while they browse your site.

At the moment LavaLust comes with file session storage driver only:

Using the Session Class

Initializing a Session

Sessions will typically run globally with each page load, so the Session class should either be initialized in your controller constructors, or it can be auto-loaded by the system. For the most part the session class will run unattended in the background, so simply initializing the class will cause it to read, create, and update sessions when necessary.

To initialize the Session class manually in your controller constructor, use the $this->call->library() method:

								
$this->call->library('session');
								
							

Once loaded, the Sessions library object will be available using:

								
$this->session;
								
							

How do Sessions work?

When a page is loaded, the session class will check to see if valid session cookie is sent by the user’s browser. If a sessions cookie does not exist (or if it doesn’t match one stored on the server or has expired) a new session will be created and saved.

If a valid session does exist, its information will be updated. With each update, the session ID may be regenerated if configured to do so.

It’s important for you to understand that once initialized, the Session class runs automatically. There is nothing you need to do to cause the above behavior to happen. You can, as you’ll see below, work with session data, but the process of reading, writing, and updating a session is automatic.

What is Session Data?

Session data is simply an array associated with a particular session ID (cookie).

If you’ve used sessions in PHP before, you should be familiar with PHP’s $_SESSION superglobal (if not, please read the content on that link).

LavaLust gives access to its session data through the same means, as it uses the session handlers’ mechanism provided by PHP. Using session data is as simple as manipulating (read, set and unset values) the $_SESSION array.

In addition, LavaLust also provides 2 special types of session data that are further explained below: flashdata and tempdata.

Retrieving Session Data

Any piece of information from the session array is available through the $_SESSION superglobal:

								
$_SESSION['item']
								
							

Or through the Session library method:

								
$this->session->userdata('item');
								
							

Where item is the array key corresponding to the item you wish to fetch. For example, to assign a previously stored ‘name’ item to the $name variable, you will do this:

								
$name = $_SESSION['name'];

// or:

$name = $this->session->userdata('name');
								
							

If you want to retrieve all of the existing userdata, you can simply omit the item key

								
$_SESSION

// or:

$this->session->userdata();
								
							

Adding Session Data

Let’s say a particular user logs into your site. Once authenticated, you could add their username and e-mail address to the session, making that data globally available to you without having to run a database query when you need it.

Alternatively, the method of assigning it as “userdata” is also available. That however passing an array containing your new data to the set_userdata() method:

								
$this->session->set_userdata($array);
								
							

Where $array is an associative array containing your new data. Here’s an example:

								
$newdata = array(
	'username'  => 'johndoe',
	'email'     => 'johndoe@some-site.com',
	'logged_in' => TRUE
);

$this->session->set_userdata($newdata);
								
							

If you want to add userdata one value at a time, set_userdata() also supports this syntax:

								
$this->session->set_userdata('some_name', 'some_value');
								
							

If you want to verify that a session value exists, simply check with isset():

								
// returns FALSE if the 'some_name' item doesn't exist or is NULL,
// TRUE otherwise:
isset($_SESSION['some_name'])
								
							

Or you can call has_userdata():

								
$this->session->has_userdata('some_name');
								
							

Removing Session Data

Just as with any other variable, unsetting a value in $_SESSION can be done through unset():

								
unset($_SESSION['some_name']);

// or multiple values:

unset(
	$_SESSION['some_name'],
	$_SESSION['another_name']
);
								
							

Also, just as set_userdata() can be used to add information to a session, unset_userdata() can be used to remove it, by passing the session key. For example, if you wanted to remove ‘some_name’ from your session data array:

								
$array_items = array('username', 'email');

$this->session->unset_userdata($array_items);
								
							

Flashdata

LavaLust supports “flashdata”, or session data that will only be available for the next request, and is then automatically cleared.

This can be very useful, especially for one-time informational, error or status messages (for example: “Record 2 deleted”).

It should be noted that flashdata variables are regular session vars, only marked in a specific way under the ‘__ci_vars’ key (please don’t touch that one, you’ve been warned).

To mark an existing item as “flashdata”:

								
$this->session->mark_as_flash('item');
								
							

If you want to mark multiple items as flashdata, simply pass the keys as an array:

								
$this->session->mark_as_flash(array('item', 'item2'));
								
							

To add flashdata:

								
$_SESSION['item'] = 'value';
$this->session->mark_as_flash('item');
								
							

Or alternatively, using the set_flashdata() method:

								
$this->session->set_flashdata('item', 'value');
								
							

You can also pass an array to set_flashdata(), in the same manner as set_userdata().

Reading flashdata variables is the same as reading regular session data through $_SESSION:

								
$_SESSION['item']
								
							

However, if you want to be sure that you’re reading “flashdata” (and not any other kind), you can also use the flashdata() method:

								
$this->session->flashdata('item');
								
							

Or to get an array with all flashdata, simply omit the key parameter:

								
$this->session->flashdata();
								
							

If you find that you need to preserve a flashdata variable through an additional request, you can do so using the keep_flashdata() method. You can either pass a single item or an array of flashdata items to keep.

								
$this->session->keep_flashdata('item');
$this->session->keep_flashdata(array('item1', 'item2', 'item3'));
								
							

Session Preferences

LavaLust will usually make everything work out of the box. However, Sessions are a very sensitive component of any application, so some careful configuration must be done. Please take your time to consider all of the options and their effects.

You’ll find the following Session related preferences in your app/config/config.php file:

Input and Ouput

Accessing form data

Using POST, GET, COOKIE, or SERVER Data

LavaLust comes with helper methods that let you fetch POST, GET, COOKIE or SERVER items. The main advantage of using the provided methods rather than fetching an item directly ($_POST['something']) is that the methods will check to see if the item is set and return NULL if not. This lets you conveniently use data without having to test whether an item exists first. In other words, normally you might do something like this:

								
$something = isset($_POST['something']) ? $_POST['something'] : NULL;
								
							

With LavaLust's built in methods you can simply do this:

								
$something = $this->io->post('something');
								
							

The main methods are:

								
//The first parameter will contain the name of the POST item you are looking for:
$this->io->post('field')
$this->io->post(array('field1', 'field2'));

//This method is identical to post(), only it fetches GET data.
$this->io->get('field')
$this->io->get(array('field1', 'field2'));

//This method is identical to post() and get(), only it fetches cookie data:
$this->io->cookie('field')
$this->io->cookie(array('some_cookie', 'some_cookie2'));

//This method is identical to the post(), get() and cookie() methods, only it fetches server data ($_SERVER):
$this->io->server('field')
$this->io->server(array('SERVER_PROTOCOL', 'REQUEST_URI'));
								
							

There are other availble methods like:

								
//This method works pretty much the same way as post() and get(), only combined. It will search through both POST and GET streams for data, looking in POST first, and then in GET:
$this->io->post_get('field')

//This method works the same way as post_get() only it looks for GET data first.
$this->io->get_post('field')

//Sets a cookie containing the values you specify. There are two ways to pass information to this method so that a cookie can be set: Array Method, and Discrete Parameters:
//options value: doamin, path, prefix, secure, and samesite
$this->io->set_cookie($name, $value, $expiration, $options = array())

//Returns the IP address for the current user. If the IP address is not valid, the method will return ‘0.0.0.0’:
$this->io->ip_address()

//Takes an IP address as input and returns TRUE or FALSE (boolean) depending on whether it is valid or not.
$this->io->valid_ip('sample_id')

//Checks to see if the HTTP_X_REQUESTED_WITH server header has been set, and returns boolean TRUE if it is or FALSE if not.
$this->io->is_ajax()

//Returns the $_SERVER['REQUEST_METHOD'], with the option to set it in uppercase or lowercase.
$this->io->method()
								
							

Other Response Methods

If you need customize responses with the ability to add and set headers, set status codes and contents you LavaLust IO class has default methods for them.

								
//Sample Response
//HTML content
$this->io->add_header('Content-Type', 'text/html');
$this->io->set_content('Hello, World!');

//or simple
$this->io->set_html_content('Hello, World!');

//Set status code
$this->io->set_status_code(200);

//Send Response
$this->io->send();
								
							

								
//Alternatively, send a JSON response (for API)
$this->io->add_header('Access-Control-Allow-Origin', '*');
$this->io->add_header('Content-Type', 'application/json');
//Or use array for add_header
$this->io->add_header([
	'Access-Control-Allow-Origin' => '*',
	'Content-Type' => 'application/json'
]);
$data = ['message' => 'Hello, World!'];
$this->io->set_status_code(200);
$this->io->send_json($data);
								
							

Config Class

The Config class provides a means to retrieve configuration preferences. These preferences can come from the default config file (app/config/config.php) or from your own custom config files.

By default, LavaLust has one primary config file, located at app/config/config.php. If you open the file using your text editor you’ll see that config items are stored in an array called $config.

You can add your own config items to this file, or if you prefer to keep your configuration items separate (assuming you even need config items), simply create your own file and save it in config folder.

Manual Loading

To load one of your custom config files you will use the following function within the controller that needs it:

								
$this->config->load('filename');
								
							

Where filename is the name of your config file, without the .php file extension.

If you need to load multiple config files normally they will be merged into one master config array. Name collisions can occur, however, if you have identically named array indexes in different config files. To avoid collisions you can set the second parameter to TRUE and each config file will be stored in an array index corresponding to the name of the config file. Example:

								
// Stored in an array with this prototype: $this->config['blog_settings'] = $config
$this->config->load('blog_settings', TRUE);
								
							

Auto-loading

If you find that you need a particular config file globally, you can have it loaded automatically by the system. To do this, open the autoload.php file, located at application/config/autoload.php, and add your config file as indicated in the file.

Fetching Config Items

To retrieve an item from your config file, use the following function:

								
$this->config->get('item_name');
								
							

Where item_name is the $config array index you want to retrieve. For example, to fetch your language choice you’ll do this:

								
$lang = $this->config->get('language');
								
							

The function returns NULL if the item you are trying to fetch does not exist.

If you are using the second parameter of the $this->config->load function in order to assign your config items to a specific index you can retrieve it by specifying the index name in the second parameter of the $this->config->get() function. Example:

								
// Loads a config file named blog_settings.php and assigns it to an index named "blog_settings"
$this->config->load('blog_settings', TRUE);

// Retrieve a config item named site_name contained within the blog_settings array
$site_name = $this->config->get('site_name', 'blog_settings');

// An alternate way to specify the same item:
$blog_config = $this->config->get('blog_settings');
$site_name = $blog_config['site_name'];
								
							

Setting a Config Item

If you would like to dynamically set a config item or change an existing one, you can do so using:

								
$this->config->set('item_name', 'item_value');
								
							

Where item_name is the $config array index you want to change, and item_value is its value.

Encryption Class

The Encryption Library provides two-way data encryption. To do so in a cryptographically secure way, it utilizes PHP extensions called OpenSSL

Initializing the Class

Like most other classes in LavaLust, the Encryption library is initialized in your controller using the $this->call->library() method:

								
$this->call->library('encryption');
//or									
$this->call->library('encryption', 'cipher type'); //cipher is optional. If empty, it will use AES-256-CBC cipher.
								
							

Once loaded, the Encryption library object will be available using:

								
$this->encryption;
								
							

By default, the Encryption Library will use the AES-256 cipher in CBC mode, using your configured encryption_key.

Encrypting and decrypting data

Encrypting and decrypting data with the already configured library settings is simple. As simple as just passing the string to the encrypt() and/or decrypt() methods:

								
$plain_text = 'This is a plain-text message!';
$ciphertext = $this->encryption->encrypt($plain_text);

// Outputs: This is a plain-text message!
echo $this->encryption->decrypt($ciphertext);
								
							

Database Configuration

LavaLust has a config file that lets you store your database connection values (username, password, database name, etc.). The config file is located at application/config/database.php.

The config settings are stored in a multi-dimensional array with this prototype:

								
$database['main'] = array(
'driver'	=> '',
'hostname'	=> '',
'port'		=> '',
'username'	=> '',
'password'	=> '',
'database'	=> '',
'charset'	=> '',
'dbprefix'	=> '',
);
								
							

Explanation Values

Connecting to your Database

Automatically Connecting

The “auto connect” feature will load and instantiate the database class with every page load. To enable “auto connecting”, add the word database to the library array, as indicated in the following file:

app/config/autoload.php

Manually Connecting

If only some of your pages require database connectivity you can manually connect to your database by adding this line of code in any function where it is needed, or in your class constructor to make the database available globally in that class.

								
$this->call->database();
								
							

If the above function does not contain any information in the first parameter it will connect to the group specified in your database config file. For most people, this is the preferred method of use.

Manually Connecting to a Database

The first parameter of this function can optionally be used to specify a particular database group from your config file, or you can even submit connection values for a database that is not specified in your config file. Examples:

To choose a specific group from your config file you can do this:

								
$this->call->database('group_name');
								
							

Where group_name is the name of the connection group from your config file.

For information on each of these values please see the configuration page.

Connecting to Multiple Databases

If you need to connect to more than one database simultaneously you can do so as follows:

								
$this->call->database();
$this->call->database('group_one');
$this->call->database('group_two');
								
							

Note: Change the words “group_one” and “group_two” to the specific group names you are connecting to. If you don't specify the group_name, it will automatically defined $this->db variable to use for database queries.

Now you can execute queries using the following:

								
$this->db->table('table_name')->get_all();
$this->group_one->table('table_name')->get_all();
$this->group_two->table('table_name')->get_all();
								
							

Query Builder

Available Methods and Usage

The following code loads and initializes the database class based on your configuration settings:

								
$this->call->database();
								
							

Once loaded the class is ready to be used as described below.

Note: If all your pages require database access you can connect automatically

raw()

This method has one require parameter which is the SQL statement.

The second parameter is an array which will be substituted to the placeholder (?) or named placeholder (:id) when statement is executed.

								
$data = $this->db->raw('select * from user where id = ?', array(1))->fetchAll();
foreach($data as $row) {
	echo $row['id'];
	echo $row['username'];
	echo $row['password'];
}

echo $this->db->row_count();
								
							

You can also use named parameters like this.

								
$data = $this->db->raw('select * from user where id = :id', array('id' => 1))->fetchAll();
foreach($data as $row) {
	echo $row['id'];
	echo $row['username'];
	echo $row['password'];
}

echo $this->db->row_count();
								
							

select()

								
# Usage 1: string parameter
$this->db->table('table')->select('column1, column2')->get_all();
# Output: "SELECT column1, column2 FROM table"

$this->db->table('table')->select('column1 AS c1, column2 AS c2')->get_all();
# Output: "SELECT column1 AS c1, column2 AS c2 FROM table"

								
							

select functions

You can use this method in 5 ways. These;

• select_min
• select_max
• select_sum
• select_avg
• select_count

								
# Usage 1:
$this->db->table('table')->select_max('price')->get();
# Output: "SELECT MAX(price) FROM table"

# Usage 2:
$this->db->table('table')->select_count('id', 'total_row')->get();
# Output: "SELECT COUNT(id) AS total_row FROM table"
								
							

table()

								
# Usage 1: string parameter
$this->db->table('table');
# Output: "SELECT * FROM table"

$this->db->table('table1, table2');
# Output: "SELECT * FROM table1, table2"

$this->db->table('table1 AS t1, table2 AS t2');
# Output: "SELECT * FROM table1 AS t1, table2 AS t2"
								
							

get() and get_all()

								
# get(): return 1 record. It has one optional parameter, yo u can set the fetchmode. example: PDO::FETCH_OBJ by
# default PDO::FETCH_ASSOC
# get_all(): return multiple records.

$this->db->table('table')->get_all();
# Output: "SELECT * FROM table"

$this->db->table('users')->select('username')->where('status', 1)->get_all();
# Output: "SELECT username FROM users WHERE status='1'"

$this->db->table('pages')->select('title')->where('id', 17)->get();
# Output: "SELECT title FROM pages WHERE id='17' LIMIT 1"
								
							

insert()

								
$bind = array(
	'username' => $username,
	'password' => $this->passwordhash($password),
	'email' => $email,
	'usertype' => $usertype,
	);

$this->db->table('user')->insert($bind);
# Output: "INSERT INTO user username, password, email, usertype VALUES ($username, $password, $email, $usertype)"
								
							

update()

								
$data = [
	'username' => 'ronmarasigan',
	'password' => 'pass',
	'activation' => 1,
	'status' => 1
];

$this->db->table('users')->where('id', 10)->update($data);
# Output: "UPDATE users SET username='ronmarasigan', password='pass', activation='1', status='1' WHERE id='10'"
								
							

delete()

								
$this->db->table('table')->where("id", 17)->delete();
# Output: "DELETE FROM table WHERE id = '17'"

# OR

$this->db->table('table')->delete();
# Output: "TRUNCATE TABLE delete"
								
							

where()

								
$where = [
	'name' => 'Ron',
	'age' => 23,
	'status' => 1
];
$this->db->table('users')->where($where)->get();
# Output: "SELECT * FROM users WHERE name='Ron' AND age='23' AND status='1' LIMIT 1"

# OR

$this->db->table('users')->where('active', 1)->get_all();
# Output: "SELECT * FROM users WHERE active='1'"

# OR

$this->db->table('users')->where('age', '>=', 18)->get_all();
# Output: "SELECT * FROM users WHERE age>='18'"

# OR

$this->db->table('users')->where('age = ? OR age = ?', [18, 20])->get_all();
# Output: "SELECT * FROM users WHERE age='18' OR age='20'"
								
							

You can use this method in 6 ways. These;

• where
• or_where
• not_where
• or_not_where
• where_null
• where_not_null

								
$this->db->table('users')->where('active', 1)->not_where('auth', 1)->get_all();
# Output: "SELECT * FROM users WHERE active = '1' AND NOT auth = '1'"

# OR

$this->db->table('users')->where('age', 20)->or_where('age', '>', 25)->get_all();
# Output: "SELECT * FROM users WHERE age = '20' OR age > '25'"

$this->db->table('users')->where_not_null('email')->get_all();
# Output: "SELECT * FROM users WHERE email IS NOT NULL"
								
							

join()

								
$this->db->table('test as t')->join('foo as f', 't.id=f.t_id')->where('t.status', 1)->get_all();
# Output: "SELECT * FROM test as t JOIN foo as f ON t.id=f.t_id WHERE t.status='1'"
								
							

You can use this method in 7 ways. These;

• join
• left_join
• right_join
• inner_join
• full_outer_join
• left_outer_join
• right_outer_join

								
$this->db->table('test as t')->left_join('foo as f', 't.id=f.t_id')->get_all();
# Output: "SELECT * FROM test as t LEFT JOIN foo as f ON t.id=f.t_id"

$this->db->table('test as t')->full_outer_join('foo as f', 't.id=f.t_id')->get_all();
# Output: "SELECT * FROM test as t FULL OUTER JOIN foo as f ON t.id=f.t_id"
								
							

grouped()

								
$this->db->table('users')
	->grouped(function($q) {
		$q->where('country', 'USA')->or_where('country', 'Philippines');
	})
	->where('status', 1)
	->get_all();
# Ouput: "SELECT * FROM users WHERE (country='USA' OR country='Philippines') AND status ='1'"
								
							

in()

								
$this->db->table('users')->where('active', 1)->in('id', [1, 2, 3])->getAll();
# Output: "SELECT * FROM users WHERE active = '1' AND id IN ('1', '2', '3')"
								
							

You can use this method in 4 ways. These;

• in
• or_in
• not_in
• or_not_in

								
$this->db->table('users')->where('active', 1)->not_in('id', [1, 2, 3])->get_all();
# Output: "SELECT * FROM users WHERE active = '1' AND id NOT IN ('1', '2', '3')"

# OR

$this->db->table('users')->where('users', 1)->or_in('id', [1, 2, 3])->get_all();
# Output: "SELECT * FROM table WHERE active = '1' OR id IN ('1', '2', '3')"

								
							

between()

								
$this->db->table('users')->where('active', 1)->between('age', 18, 25)->get_all();
# Output: "SELECT * FROM users WHERE active = '1' AND age BETWEEN '18' AND '25'"
								
							

You can use this method in 4 ways. These;

• between
• or_between
• not_between
• or_not_between

								
$this->db->table('users')->where('active', 1)->not_between('age', 18, 25)->get_all();
# Output: "SELECT * FROM users WHERE active = '1' AND age NOT BETWEEN '18' AND '25'"

# OR

$this->db->table('users')->where('active', 1)->or_between('age', 18, 25)->get_all();
# Output: "SELECT * FROM users WHERE active = '1' OR age BETWEEN '18' AND '25'"
								
							

like()

								
$this->db->table('books')->like('title', "%php%")->get_all();
# Output: "SELECT * FROM books WHERE title LIKE '%php%'"
								
							

You can use this method in 4 ways. These;

• like
• or_like
• not_like
• or_not_like

								
$this->db->table('books')->where('active', 1)->not_like('tags', '%dot-net%')->get_all();
# Output: "SELECT * FROM books WHERE active = '1' AND tags NOT LIKE '%dot-net%'"

# OR

$this->db->table('books')->like('bio', '%php%')->or_like('bio', '%java%')->get_all();
# Output: "SELECT * FROM books WHERE bio LIKE '%php%' OR bio LIKE '%java%'"
								
							

group_by()

								
# Usage 1: One parameter
$this->db->table('books')->where('status', 1)->group_by('cat_id')->get_all();
# Output: "SELECT * FROM books WHERE status = '1' GROUP BY cat_id"

# Usage 1: Array parameter
$this->db->table('books')->where('status', 1)->group_by(['cat_id', 'user_id'])->get_all();
# Output: "SELECT * FROM books WHERE status = '1' GROUP BY cat_id, user_id"
								
							

having()

								
$this->db->table('books')->where('status', 1)->group_by('city')->having('COUNT(person)', 100)->get_all();
# Output: "SELECT * FROM books WHERE status='1' GROUP BY city HAVING COUNT(person) > '100'"

# OR

$this->db->table('employee')->where('active', 1)->group_by('department_id')->having('AVG(salary)', '<=', 500)->get_all();
# Output: "SELECT * FROM employee WHERE active='1' GROUP BY department_id HAVING AVG(salary) <= '500'"

# OR

$this->db->table('employee')->where('active', 1)->group_by('department_id')->having('AVG(salary) > ? AND MAX(salary) < ?', [250, 1000])->get_all();
# Output: "SELECT * FROM employee WHERE active='1' GROUP BY department_id HAVING AVG(salary) > '250' AND MAX(salary) < '1000'"
								
							

order_by()

								
# Usage 1: One parameter
$this->db->table('test')->where('status', 1)->order_by('id', 'ASC')->get_all();
# Output: "SELECT * FROM test WHERE status='1' ORDER BY id ASC"
								
							

limit()

								
# Usage 1: One parameter
$this->db->table('table')->limit(10)->get_all();
# Output: "SELECT * FROM table LIMIT 10"
#or
# Usage 2: One parameter
$this->db->table('table')->limit(10, 20)->get_all();
# Output: "SELECT * FROM table LIMIT 10"
								
							

offset()

								
# Usage 1: One parameter
$this->db->table('table')->offset(10)->get_all();
# Output: "SELECT * FROM table OFFSET 10"
								
							

pagination()

								
# Usage 1: One parameter
$this->db->table('table')->pagination(10, 1)->get_all();
# Output: "SELECT * FROM table LIMIT 10 OFFSET 10"
								
							

transaction()

								
$this->db->transaction();

$data = [
	'title' => 'new title',
	'status' => 2
];
$this->db->table('table')->where('id', 10)->update($data);

$this->db->commit();
# OR
$this->db->rollBack();
								
							

String Helper