added documentation to main repository.
This commit is contained in:
Taylor Otwell
52
documentation/database/config.md
Normal file
52
documentation/database/config.md
Normal file
@@ -0,0 +1,52 @@
|
||||
## Database Configuration
|
||||
|
||||
- [Quick Start Using SQLite](#quick)
|
||||
- [Configuring MySQL or PostgreSQL](#server)
|
||||
- [Setting The Default Connection Name](#default)
|
||||
|
||||
Database configuration in Laravel is easy. The hardest part is deciding which database to use. Three popular open-source databases are supported out of the box:
|
||||
|
||||
- MySQL
|
||||
- PostgreSQL
|
||||
- SQLite
|
||||
|
||||
All of the database configuration options live in the **application/config/db.php** file. Let's get started.
|
||||
|
||||
<a name="quick"></a>
|
||||
### Quick Start Using SQLite
|
||||
|
||||
[SQLite](http://sqlite.org) is an awesome, zero-configuration database system. By default, Laravel is configured to use a SQLite database. Really, you don't have to change anything. Just drop a SQLite database named **application.sqlite** into the **application/storage/db directory**. You're done.
|
||||
|
||||
Of course, if you want to name your database something besides "application", you can modify the database option in the SQLite section of the **application/config/db.php** file:
|
||||
|
||||
'sqlite' => array(
|
||||
'driver' => 'sqlite',
|
||||
'database' => 'your_database_name',
|
||||
)
|
||||
|
||||
If your application receives less than 100,000 hits per day, SQLite should be suitable for production use in your application. Otherwise, consider using MySQL or PostgreSQL.
|
||||
|
||||
> **Note:** Need a good SQLite manager? Check out this [Firefox extension](https://addons.mozilla.org/en-US/firefox/addon/sqlite-manager/).
|
||||
|
||||
<a name="server"></a>
|
||||
### Configuring MySQL or PostgreSQL
|
||||
|
||||
If you are using MySQL or PostgreSQL, you will need to edit the configuration options in **application/config/db.php**. Don't worry. In the configuration file, sample configurations exist for both systems. All you need to do is change the options as necessary for your server and set the default connection name.
|
||||
|
||||
'mysql' => array(
|
||||
'driver' => 'mysql',
|
||||
'host' => 'localhost',
|
||||
'database' => 'database',
|
||||
'username' => 'root',
|
||||
'password' => 'password',
|
||||
'charset' => 'utf8',
|
||||
),
|
||||
|
||||
<a name="default"></a>
|
||||
### Setting The Default Connection Name
|
||||
|
||||
As you have probably noticed, each database connection defined in the **application/config/db.php** file has a name. By default, there are three connections defined: **sqlite**, **mysql**, and **pgsql**. You are free to change these connection names. The default connection can be specified via the **default** option:
|
||||
|
||||
'default' => 'sqlite';
|
||||
|
||||
The default connection will always be used by the [fluent query builder](/docs/database/query) and [Eloquent ORM](/docs/database/eloquent). If you need to change the default connection during a request, use the **Config::set** method.
|
||||
306
documentation/database/eloquent.md
Normal file
306
documentation/database/eloquent.md
Normal file
@@ -0,0 +1,306 @@
|
||||
## Eloquent ORM
|
||||
|
||||
- [Conventions](#conventions)
|
||||
- [Retrieving Models](#get)
|
||||
- [Aggregates](#aggregates)
|
||||
- [Inserting & Updating Models](#save)
|
||||
- [Relationships](#relationships)
|
||||
- [Eager Loading](#eager)
|
||||
|
||||
An ORM is an [object-relational mapper](http://en.wikipedia.org/wiki/Object-relational_mapping), and Laravel has one that you will absolutely love to use. It is named "Eloquent" because it allows you to work with your database objects and relationships using an eloquent and expressive syntax. In general, you will define one Eloquent model for each table in your database. To get started, let's define a simple model:
|
||||
|
||||
class User extends Eloquent {}
|
||||
|
||||
Nice! Notice that our model extends the **Eloquent** class. This class will provide all of the functionality you need to start working eloquently with your database.
|
||||
|
||||
> **Note:** Typically, Eloquent models live in the **application/models** directory.
|
||||
|
||||
<a name="conventions"></a>
|
||||
### Conventions
|
||||
|
||||
Eloquent makes a few basic assumptions about your database structure:
|
||||
|
||||
- Each table should have a primary key named **id**.
|
||||
- Each table name should be the plural form of its corresponding model name.
|
||||
|
||||
Sometimes you may wish to use a table name other than the plural form of your model. No problem. Just add a static **table** property your model:
|
||||
|
||||
class User extends Eloquent {
|
||||
|
||||
public static $table = 'my_users';
|
||||
|
||||
}
|
||||
|
||||
<a name="get"></a>
|
||||
### Retrieving Models
|
||||
|
||||
Retrieving models using Eloquent is refreshingly simple. The most basic way to retrieve an Eloquent model is the static **find** method. This method will return a single model by primary key with properties corresponding to each column on the table:
|
||||
|
||||
$user = User::find(1);
|
||||
|
||||
echo $user->email;
|
||||
|
||||
The find method will execute a query that looks something like this:
|
||||
|
||||
SELECT * FROM "users" WHERE "id" = 1
|
||||
|
||||
Need to retrieve an entire table? Just use the static **all** method:
|
||||
|
||||
$users = User::all();
|
||||
|
||||
foreach ($users as $user)
|
||||
{
|
||||
echo $user->email;
|
||||
}
|
||||
|
||||
Of course, retrieving an entire table isn't very helpful. Thankfully, **every method that is available through the fluent query builder is available in Eloquent**. Just begin querying your model with a static call to one of the [query builder](/docs/database/query) methods, and execute the query using the **get** or **first** method. The get method will return an array of models, while the first method will return a single model:
|
||||
|
||||
$user = User::where('email', '=', $email)->first();
|
||||
|
||||
$user = User::where_email($email)->first();
|
||||
|
||||
$users = User::where_in('id', array(1, 2, 3))->or_where('email', '=', $email)->get();
|
||||
|
||||
$users = User::order_by('votes', 'desc')->take(10)->get();
|
||||
|
||||
> **Note:** If no results are found, the **first** method will return NULL. The **all** and **get** methods return an empty array.
|
||||
|
||||
<a name="aggregates"></a>
|
||||
### Aggregates
|
||||
|
||||
Need to get a **MIN**, **MAX**, **AVG**, **SUM**, or **COUNT** value? Just pass the column to the appropriate method:
|
||||
|
||||
$min = User::min('id');
|
||||
|
||||
$max = User::max('id');
|
||||
|
||||
$avg = User::avg('id');
|
||||
|
||||
$sum = User::sum('id');
|
||||
|
||||
$count = User::count();
|
||||
|
||||
Of course, you may wish to limit the query using a WHERE clause first:
|
||||
|
||||
$count = User::where('id', '>', 10)->count();
|
||||
|
||||
<a name="save"></a>
|
||||
### Inserting & Updating Models
|
||||
|
||||
Inserting Eloquent models into your tables couldn't be easier. First, instantiate a new model. Second, set its properties. Third, call the **save** method:
|
||||
|
||||
$user = new User;
|
||||
|
||||
$user->email = 'example@gmail.com';
|
||||
$user->password = 'secret';
|
||||
|
||||
$user->save();
|
||||
|
||||
Updating models is just as simple. Instead of instantiating a new model, retrieve one from your database. Then, set its properties and save:
|
||||
|
||||
$user = User::find(1);
|
||||
|
||||
$user->email = 'new_email@gmail.com';
|
||||
$user->password = 'new_secret';
|
||||
|
||||
$user->save();
|
||||
|
||||
Need to maintain creation and update timestamps on your database records? With Eloquent, you don't have to worry about it. Just add a static **timestamps** property to your model:
|
||||
|
||||
class User extends Eloquent {
|
||||
|
||||
public static $timestamps = true;
|
||||
|
||||
}
|
||||
|
||||
Next, add **created_at** and **updated_at** date columns to your table. Now, whenever you save the model, the creation and update timestamps will be set automatically. You're welcome.
|
||||
|
||||
> **Note:** You can change the default timezone of your application in the **application/config/application.php** file.
|
||||
|
||||
<a name="relationships"></a>
|
||||
### Relationships
|
||||
|
||||
Unless you're doing it wrong, your database tables are probably related to one another. For instance, an order may belong to a user. Or, a post may have many comments. Eloquent makes defining relationships and retrieving related models simple and intuitive. Laravel supports three types of relationships:
|
||||
|
||||
- [One-To-One](#one-to-one)
|
||||
- [One-To-Many](#one-to-many)
|
||||
- [Many-To-Many](#many-to-many)
|
||||
|
||||
To define a relationship on an Eloquent model, you simply create a method that returns the result of either the **has\_one**, **has\_many**, **belongs\_to**, or **has\_and\_belongs\_to\_many** method. Let's examine each one in detail.
|
||||
|
||||
<a name="one-to-one"></a>
|
||||
#### One-To-One
|
||||
|
||||
A one-to-one relationship is the most basic form of relationship. For example, let's pretend a user has one phone. Simply describe this relationship to Eloquent:
|
||||
|
||||
class User extends Eloquent {
|
||||
|
||||
public function phone()
|
||||
{
|
||||
return $this->has_one('Phone');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Notice that the name of the related model is passed to the **has_one** method. You can now retrieve the phone of a user through the **phone** method:
|
||||
|
||||
$phone = User::find(1)->phone()->first();
|
||||
|
||||
Let's examine the SQL performed by this statement. Two queries will be performed: one to retrieve the user and one to retrieve the user's phone:
|
||||
|
||||
SELECT * FROM "users" WHERE "id" = 1
|
||||
|
||||
SELECT * FROM "phones" WHERE "user_id" = 1
|
||||
|
||||
Note that Eloquent assumes the foreign key of the relationship will be **user\_id**. Most foreign keys will follow this **model\_id** convention; however, if you want to use a different column name as the foreign key, just pass it in the second parameter to the method:
|
||||
|
||||
return $this->has_one('Phone', 'my_foreign_key');
|
||||
|
||||
Want to just retrieve the user's phone without calling the first method? No problem. Just use the **dynamic phone property**. Eloquent will automatically load the relationship for you, and is even smart enough to know whether to call the get (for one-to-many relationships) or first (for one-to-one relationships) method:
|
||||
|
||||
$phone = User::find(1)->phone;
|
||||
|
||||
What if you need to retrieve a phone's user? Since the foreign key (**user\_id**) is on the phones table, we should describe this relationship using the **belongs\_to** method. It makes sense, right? Phones belong to users. When using the **belongs\_to** method, the name of the relationship method should correspond to the foreign key (sans the **\_id**). Since the foreign key is **user\_id**, your relationship method should be named **user**:
|
||||
|
||||
class Phone extends Eloquent {
|
||||
|
||||
public function user()
|
||||
{
|
||||
return $this->belongs_to('User');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Great! You can now access a User model through a Phone model using either your relationship method or dynamic property:
|
||||
|
||||
echo Phone::find(1)->user()->first()->email;
|
||||
|
||||
echo Phone::find(1)->user->email;
|
||||
|
||||
<a name="one-to-many"></a>
|
||||
#### One-To-Many
|
||||
|
||||
Assume a blog post has many comments. It's easy to define this relationship using the **has_many** method:
|
||||
|
||||
class Post extends Eloquent {
|
||||
|
||||
public function comments()
|
||||
{
|
||||
return $this->has_many('Comment');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Now, simply access the post comments through the relationship method or dynamic property:
|
||||
|
||||
$comments = Post::find(1)->comments()->get();
|
||||
|
||||
$comments = Post::find(1)->comments;
|
||||
|
||||
Both of these statements will execute the following SQL:
|
||||
|
||||
SELECT * FROM "posts" WHERE "id" = 1
|
||||
|
||||
SELECT * FROM "comments" WHERE "post_id" = 1
|
||||
|
||||
Want to join on a different foreign key? No problem. Just pass it in the second parameter to the method:
|
||||
|
||||
return $this->has_many('Comment', 'my_foreign_key');
|
||||
|
||||
You may be wondering: _If the dynamic properties return the relationship and require less keystokes, why would I ever use the relationship methods?_ Actually, relationship methods are very powerful. They allow you to continue to chain query methods before retrieving the relationship. Check this out:
|
||||
|
||||
echo Post::find(1)->comments()->order_by('votes', 'desc')->take(10)->get();
|
||||
|
||||
<a name="many-to-many"></a>
|
||||
#### Many-To-Many
|
||||
|
||||
Many-to-many relationships are the most complicated of the three relationships. But don't worry, you can do this. For example, assume a User has many Roles, but a Role can also belong to many Users. Three database tables must be created to accomplish this relationship: a **users** table, a **roles** table, and a **roles_users** table. The structure for each table looks like this:
|
||||
|
||||
**Users:**
|
||||
|
||||
id - INTEGER
|
||||
email - VARCHAR
|
||||
|
||||
**Roles:**
|
||||
|
||||
id - INTEGER
|
||||
name - VARCHAR
|
||||
|
||||
**Roles_Users:**
|
||||
|
||||
user_id - INTEGER
|
||||
role_id - INTEGER
|
||||
|
||||
Now you're ready to define the relationship on your models using the **has\_and\_belongs\_to\_many** method:
|
||||
|
||||
class User extends Eloquent {
|
||||
|
||||
public function roles()
|
||||
{
|
||||
return $this->has_and_belongs_to_many('Role');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Great! Now it's time to retrieve a user's roles:
|
||||
|
||||
$roles = User::find(1)->roles()->get();
|
||||
|
||||
Or, as usual, you may retrieve the relationship through the dynamic roles property:
|
||||
|
||||
$roles = User::find(1)->roles;
|
||||
|
||||
As you may have noticed, the default name of the intermediate table is the plural names of the two related models arranged alphabetically and concatenated by an underscore. However, you are free to specify your own table name. Simply pass the table name in the second parameter to the **has\_and\_belongs\_to\_many** method:
|
||||
|
||||
class User extends Eloquent {
|
||||
|
||||
public function roles()
|
||||
{
|
||||
return $this->has_and_belongs_to_many('Role', 'user_roles');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
<a name="eager"></a>
|
||||
### Eager Loading
|
||||
|
||||
Eager loading exists to alleviate the N + 1 query problem. Exactly what is this problem? Well, pretend each Book belongs to an Author. We would describe this relationship like so:
|
||||
|
||||
class Book extends Eloquent {
|
||||
|
||||
public function author()
|
||||
{
|
||||
return $this->belongs_to('Author');
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Now, examine the following code:
|
||||
|
||||
foreach (Book::all() as $book)
|
||||
{
|
||||
echo $book->author->name;
|
||||
}
|
||||
|
||||
How many queries will be executed? Well, one query will be executed to retrieve all of the books from the table. However, another query will be required for each book to retrieve the author. To display the author name for 25 books would require **26 queries**. See how the queries can add up fast?
|
||||
|
||||
Thankfully, you can eager load the author models using the **with** method. Simply mention the **function name** of the relationship you wish to eager load:
|
||||
|
||||
foreach (Book::with('author')->get() as $book)
|
||||
{
|
||||
echo $book->author->name;
|
||||
}
|
||||
|
||||
In this example, **only two queries will be executed**!
|
||||
|
||||
SELECT * FROM "books"
|
||||
|
||||
SELECT * FROM "authors" WHERE "id" IN (1, 2, 3, 4, 5, ...)
|
||||
|
||||
Obviously, wise use of eager loading can dramatically increase the performance of your application. In the example above, eager loading cut the execution time in half.
|
||||
|
||||
Need to eager load more than one relationship? It's easy:
|
||||
|
||||
$books = Book::with('author', 'publisher')->get();
|
||||
|
||||
> **Note:** When eager loading, the call to the static **with** method must always be at the beginning of the query.
|
||||
216
documentation/database/query.md
Normal file
216
documentation/database/query.md
Normal file
@@ -0,0 +1,216 @@
|
||||
## Fluent Query Builder
|
||||
|
||||
- [Retrieving Records](#get)
|
||||
- [Building Where Clauses](#where)
|
||||
- [Dynamic Where Clauses](#dynamic)
|
||||
- [Table Joins](#joins)
|
||||
- [Ordering Results](#ordering)
|
||||
- [Skip & Take](#limit)
|
||||
- [Aggregates](#aggregates)
|
||||
- [Inserting Records](#insert)
|
||||
- [Updating Records](#update)
|
||||
- [Deleting Records](#delete)
|
||||
|
||||
Laravel provides an awesome, easy-to-use fluent interface for building SQL queries and working with your database. All queries use prepared statements and are protected against SQL injection. Working with your database doesn't have to be a headache.
|
||||
|
||||
You can begin a fluent query using the **table** method on the DB class. Just mention the table you wish to query:
|
||||
|
||||
$query = DB::table('users');
|
||||
|
||||
You now have a fluent query builder for the "users" table. Using this query builder, you can retrieve, insert, update, or delete records from the table.
|
||||
|
||||
<a name="get"></a>
|
||||
### Retrieving Records
|
||||
|
||||
There are two methods available for retrieving records using a fluent query: **get** and **first**. The **get** method will return an array of records from your database. Each record will be an object with properties corresponding to the columns of the table:
|
||||
|
||||
$users = DB::table('users')->get();
|
||||
|
||||
foreach ($users as $user)
|
||||
{
|
||||
echo $user->email;
|
||||
}
|
||||
|
||||
Instead of returning an array, the **first** method will return a single object:
|
||||
|
||||
$user = DB::table('users')->first();
|
||||
|
||||
echo $user->email;
|
||||
|
||||
It's easy to limit the columns returned by your query. Simply pass an array of columns you want into the **get** or **first** method:
|
||||
|
||||
$user = DB::table('users')->get(array('id', 'email as user_email'));
|
||||
|
||||
Need to get distinct records from the database? It's easy. Call the **distinct** method before retrieving your records:
|
||||
|
||||
$user = DB::table('users')->distinct()->get();
|
||||
|
||||
> **Note:** If no results are found, the **first** method will return NULL. The **get** method will return an empty array.
|
||||
|
||||
<a name="where"></a>
|
||||
### Building Where Clauses
|
||||
|
||||
#### where and or\_where
|
||||
|
||||
Building WHERE clauses in Laravel is painless. There are a variety of methods to assist you. The most basic of these methods are the **where** and **or_where** methods. Here is how to use them:
|
||||
|
||||
return DB::table('users')
|
||||
->where('id', '=', 1)
|
||||
->or_where('email', '=', 'example@gmail.com')
|
||||
->first();
|
||||
|
||||
Of course, you are not limited to simply checking equality. You may also use **greater-than**, **less-than**, **not-equal**, and **like**:
|
||||
|
||||
return DB::table('users')
|
||||
->where('id', '>', 1)
|
||||
->or_where('name', 'LIKE', '%Taylor%')
|
||||
->first();
|
||||
|
||||
You may have assumed that the **where** method will add to the query using an AND condition, while the **or_where** method will use an OR condition. You assumed correctly.
|
||||
|
||||
#### where\_in, where\_not\_in, or\_where\_in, and or\_where\_not\_in
|
||||
|
||||
The suite of **where_in** methods allows you to easily construct queries that search an array of values:
|
||||
|
||||
DB::table('users')->where_in('id', array(1, 2, 3))->get();
|
||||
|
||||
DB::table('users')->where_not_in('id', array(1, 2, 3))->get();
|
||||
|
||||
DB::table('users')
|
||||
->where('email', '=', 'example@gmail.com')
|
||||
->or_where_in('id', array(1, 2, 3))
|
||||
->get();
|
||||
|
||||
DB::table('users')
|
||||
->where('email', '=', 'example@gmail.com')
|
||||
->or_where_not_in('id', array(1, 2, 3))
|
||||
->get();
|
||||
|
||||
#### where\_null, where\_not\_null, or\_where\_null, and or\_where\_not\_null
|
||||
|
||||
The suite of **where_null** methods makes checking for NULL values a piece of cake:
|
||||
|
||||
return DB::table('users')->where_null('updated_at')->get();
|
||||
|
||||
return DB::table('users')->where_not_null('updated_at')->get();
|
||||
|
||||
return DB::table('users')
|
||||
->where('email', '=', 'example@gmail.com')
|
||||
->or_where_null('updated_at')
|
||||
->get();
|
||||
|
||||
return DB::table('users')
|
||||
->where('email', '=', 'example@gmail.com')
|
||||
->or_where_not_null('updated_at')
|
||||
->get();
|
||||
|
||||
<a name="dynamic"></a>
|
||||
### Dynamic Where Clauses
|
||||
|
||||
Ready for some really beautiful syntax? Check out **dynamic where methods**:
|
||||
|
||||
$user = DB::table('users')->where_email('example@gmail.com')->first();
|
||||
|
||||
$user = DB::table('users')->where_email_and_password('example@gmail.com', 'secret');
|
||||
|
||||
$user = DB::table('users')->where_id_or_name(1, 'Fred');
|
||||
|
||||
Aren't they a breathe of fresh air?
|
||||
|
||||
<a name="joins"></a>
|
||||
### Table Joins
|
||||
|
||||
Need to join to another table? Try the **join** and **left\_join** methods:
|
||||
|
||||
DB::table('users')
|
||||
->join('phone', 'users.id', '=', 'phone.user_id')
|
||||
->get(array('users.email', 'phone.number'));
|
||||
|
||||
The **table** you wish to join is passed as the first parameter. The remaining three parameters are used to construct the **ON** clause of the join.
|
||||
|
||||
Once you know how to use the join method, you know how to **left_join**. The method signatures are the same:
|
||||
|
||||
DB::table('users')
|
||||
->left_join('phone', 'users.id', '=', 'phone.user_id')
|
||||
->get(array('users.email', 'phone.number'));
|
||||
|
||||
<a name="ordering"></a>
|
||||
### Ordering Results
|
||||
|
||||
You can easily order the results of your query using the **order_by** method. Simply mention the column and direction (desc or asc) of the sort:
|
||||
|
||||
return DB::table('users')->order_by('email', 'desc')->get();
|
||||
|
||||
Of course, you may sort on as many columns as you wish:
|
||||
|
||||
return DB::table('users')
|
||||
->order_by('email', 'desc')
|
||||
->order_by('name', 'asc')
|
||||
->get();
|
||||
|
||||
<a name="limit"></a>
|
||||
### Skip & Take
|
||||
|
||||
If you would like to **LIMIT** the number of results returned by your query, you can use the **take** method:
|
||||
|
||||
return DB::table('users')->take(10)->get();
|
||||
|
||||
To set the **OFFSET** of your query, use the **skip** method:
|
||||
|
||||
return DB::table('users')->skip(10)->get();
|
||||
|
||||
<a name="aggregates"></a>
|
||||
### Aggregates
|
||||
|
||||
Need to get a **MIN**, **MAX**, **AVG**, **SUM**, or **COUNT** value? Just pass the column to the query:
|
||||
|
||||
$min = DB::table('users')->min('age');
|
||||
|
||||
$max = DB::table('users')->max('weight');
|
||||
|
||||
$avg = DB::table('users')->avg('salary');
|
||||
|
||||
$sum = DB::table('users')->sum('votes');
|
||||
|
||||
$count = DB::table('users')->count();
|
||||
|
||||
Of course, you may wish to limit the query using a WHERE clause first:
|
||||
|
||||
$count = DB::table('users')->where('id', '>', 10)->count();
|
||||
|
||||
<a name="insert"></a>
|
||||
### Inserting Records
|
||||
|
||||
Inserting records is amazingly easy using the **insert** method. The method only expects an array of values to insert. It couldn't be simpler. The insert method will simply return true or false, indicating whether the query was successful:
|
||||
|
||||
DB::table('users')->insert(array('email' => 'example@gmail.com'));
|
||||
|
||||
Inserting a record that has an auto-incrementing ID? You can use the **insert\_get\_id** method to insert a record and retrieve the ID:
|
||||
|
||||
$id = DB::table('users')->insert_get_id(array('email' => 'example@gmail.com'));
|
||||
|
||||
> **Note:** The **insert\_get\_id** method expects the name of the auto-incrementing column to be "id".
|
||||
|
||||
<a name="update"></a>
|
||||
### Updating Records
|
||||
|
||||
Updating records is just as simple as inserting them. Simply pass an array of values to the **update** method:
|
||||
|
||||
$affected = DB::table('users')->update(array('email' => 'new_email@gmail.com'));
|
||||
|
||||
Of course, when you only want to update a few records, you should add a WHERE clause before calling the update method:
|
||||
|
||||
$affected = DB::table('users')
|
||||
->where('id', '=', 1)
|
||||
->update(array('email' => 'new_email@gmail.com'));
|
||||
|
||||
<a name="delete"></a>
|
||||
### Deleting Records
|
||||
|
||||
When you want to delete records from your database, simply call the **delete** method:
|
||||
|
||||
$affected = DB::table('users')->where('id', '=', 1)->delete();
|
||||
|
||||
Want to quickly delete a record by its ID? No problem. Just pass the ID into the delete method:
|
||||
|
||||
$affected = DB::table('users')->delete(1);
|
||||
33
documentation/database/usage.md
Normal file
33
documentation/database/usage.md
Normal file
@@ -0,0 +1,33 @@
|
||||
## Database Usage
|
||||
|
||||
### Queries
|
||||
|
||||
Running queries against a database connection is a breeze using the **query** method on the DB class:
|
||||
|
||||
$users = DB::query('select * from users');
|
||||
|
||||
The **query** method also allows you to specify bindings for your query in the second parameter to the method:
|
||||
|
||||
$users = DB::query('select * from users where name = ?', array('test'));
|
||||
|
||||
The return value of the query method depends on the type of query that is executed:
|
||||
|
||||
- **SELECT** statements will return an array of stdClass objects with properties corresponding to each column on the table.
|
||||
- **INSERT** statements will return **true** or **false**, depending on the success of the query.
|
||||
- **UPDATE** and **DELETE** statements will return the number of rows affected by the query.
|
||||
|
||||
### Connections
|
||||
|
||||
Need to get the raw PDO object for a connection? It's easy. Just mention the connection name to the **connection** method on the DB class:
|
||||
|
||||
$pdo = DB::connection('sqlite');
|
||||
|
||||
> **Note:** If no connection name is specified, the **default** connection will be returned.
|
||||
|
||||
### Driver
|
||||
|
||||
Want to know which PDO driver is being used for a connection? Check out the **driver** method:
|
||||
|
||||
$driver = DB::driver('connection_name');
|
||||
|
||||
> **Note:** If no connection name is specified, the **default** connection driver will be returned.
|
||||
Reference in New Issue
Block a user