# Database plugin

The database plugin is installed by default in every copy of Baserow. Without it you 
can't really do anything with the application. In short this is the plugin that allows
creating a database with a spreadsheet like interface. You will notice that everything
has been build around this concept.

## Tables

Each database application can have multiple tables and a table is exactly as what you
might suspect. It can contain multiple fields, which are basically the columns, and 
rows. Every table has its own schema representation in the PostgreSQL/MySQL/SQLite 
database.

There is a `baserow.contrib.database.table.handler.TableHandler` handler class that has
all kinds of methods related to creating, modifying and deleting tables. Another nice
thing is that a Django model of the table can easily be generated. Lets say you have 
the following table with id `id` and you want select all the data.

| Model name | Brand | Price |
|------------|-------|-------|
| 3 Series   | BTW   | 30000 |
| A4         | Audi  | 25000 |
| Model 3    | Tesla | 50000 |

```python
from baserow.contrib.database.table.models import Table

cars_table = Table.objects.get(pk=ID_REFERENCED_TABLE_ABOVE)
# If you set the attribute_names to True the attribute name is going to be the field 
# name provided by the user instead of field_{id}
cars_model = cars_table.get_model(attribute_names=True)

for car in cars_model.objects.all():
    print(car.id, car.model_name, car.price)

# Results in:
# 1 3 series 30000
# 2 A4 30000
# 2 Model 3 30000
```

## Fields

A field is actually a column head of a table, it accepts only a certain type as data 
value. A field can for example be a number field that accepts two placements after the 
comma. If a new field is added to a table it is also added as column to the table 
representation in the database. The column name in the database will be field_{id}.
The fields can be created, modified and deleted via the 
`baserow.contrib.database.fields.handler.FieldHandler` and via the REST API. Several 
field types have been included by default.

> Field types can be added via a plugins. More about that on the 
> [field type plugin page](../plugins/field-type.md).

* `text`: Single line text.
* `long_text`: Multi line text.
* `number`: A number that can optionally be negative and optionally be a decimal.
* `boolean`: Just holds true or false.
* `date`: A date field in EU, ISO or USA format that can optionally include time am/pm 
  format.

## Views

Views define how the table data is displayed to the user. By default the `grid` view 
type is included and that displays the data in spreadsheet like interface. Per table
multiple views can be added and each view has its own settings. If you for example have
two grid views and you change the width of a certain field in grid A then it only 
changes for grid A and not for grid B. The views can be created, modified and deleted 
via the `baserow.contrib.database.views.handler.ViewHandler` and via the REST API.

> View types can be added via a plugins. More about that on the 
> [view type plugin page](../plugins/view-type.md).

### Rows

Rows are the table data. The values that are accepted depend on the fields of the 
table. The data is stored in the representation table in the database. In the example 
below we will insert a single row of data in a table we have just created via the 
python shell. The same result could be achieved via the REST API.

```python
from django.contrib.auth import get_user_model 
from baserow.contrib.database.table.models import Table
from baserow.contrib.database.fields.handler import FieldHandler
from baserow.contrib.database.rows.handler import RowHandler

User = get_user_model()
user = User.objects.get(pk=1)
table = Table.objects.get(pk=10)

name = FieldHandler().create_field(user, table, 'text', name='Name')
price = FieldHandler().create_field(user, table, 'number', name='Price')
row = RowHandler().create_row(user, table, {
    f'field_{name.id}': 'Smartphone',
    f'field_{price.id}': 300
})

model = table.get_model()
rows = model.objects.all()

print(rows[0].name)
print(rows[0].price)

# Which will result in:
# Smartphone
# 300
```