How To Use Views in SQL | DigitalOcean (2023)


Structured Query Language (SQL) employs a variety of different data structures, with tables being one of the most commonly used. However, tables have certain limitations. For instance, you can’t limit users to only have access to part of a table. A user must be granted access to an entire table, not just a few columns within it.

As another example, say you want to combine data from multiple other tables into a new structure, but you also don’t want to delete the original tables. You could just create another table, but then you’d have redundant data stored in multiple places. This could cause a lot of inconvenience: if some of your data changed, you’d have to update it in multiple places. In cases like these, views can come in handy.

In SQL, a view is a virtual table whose contents are the result of a specific query to one or more tables, known as base tables. This guide provides an overview of what SQL views are and why they can be useful. It also highlights how you can create, query, modify, and destroy views using standard SQL syntax.


In order to follow this guide, you will need a computer running some type of relational database management system (RDBMS) that uses SQL. The instructions and examples in this guide were validated using the following environment:

  • A server running Ubuntu 20.04, with a non-root user with sudo administrative privileges and a firewall configured with UFW, as described in our initial server setup guide for Ubuntu 20.04.
  • MySQL installed and secured on the server, as outlined in How To Install MySQL on Ubuntu 20.04. This guide was verified with a newly-created user, as described in Step 3.

Note: Please note that many RDBMSs use their own unique implementations of SQL. Although the commands outlined in this tutorial will work on most RDBMSs, the exact syntax or output may differ if you test them on a system other than MySQL.

You’ll also need a database with some tables loaded with sample data which you can use to practice creating and working with views. We encourage you to go through the following Connecting to MySQL and Setting up a Sample Database section for details on how to connect to a MySQL server and create the testing database used in examples throughout this guide.

Connecting to MySQL and Setting up a Sample Database

If your SQL database system runs on a remote server, SSH into your server from your local machine:

  1. ssh sammy@your_server_ip

Then open up the MySQL server prompt, replacing sammy with the name of your MySQL user account:

  1. mysql -u sammy -p

From the prompt, create a database named views_db:

  1. CREATE DATABASE views_db;

If the database was created successfully, you’ll receive output like the following:


Query OK, 1 row affected (0.01 sec)

To select the views_db database, run the following USE statement:

(Video) How Views Work in SQL and Why You Should Use Them

  1. USE views_db;


Database changed

After selecting views_db, create a few tables within it.

To follow along with the examples used in this guide, imagine that you run an at-home dog care service. You decide to use an SQL database to store information about each dog you’ve signed up for the service, as well as each of the dog care professionals your service employs. To keep things organized, you decide you need two tables: one representing the employees and one representing the dogs cared for by your service. The table representing your employees will contain the following columns:

  • emp_id: an identification number for each dog carer you employ, expressed with the int data type. This column will serve as the table’s primary key, meaning that each value will function as a unique identifier for its respective row. Because every value in a primary key must be unique, this column will also have a UNIQUE constraint applied to it.
  • emp_name: each employee’s name expressed using the varchar data type with a maximum of 20 characters.

Run the following CREATE TABLE statement to create a table named employees that has these two columns:

  1. CREATE TABLE employees (
  2. emp_id int UNIQUE,
  3. emp_name varchar(20),
  4. PRIMARY KEY (emp_id)
  5. );

The other table representing each dog will contain these six columns:

  • dog_id: an identification number for each dog staying at the hotel, expressed with the int data type. Like the emp_id column in the employees table, this column will serve as the primary key for the dogs table.
  • dog_name: each dog’s name, expressed using the varchar data type with a maximum of 20 characters.
  • walker: this column stores the employee ID number of the employee assigned to care for each respective dog.
  • walk_distance: the distance each dog should walk when they’re taken out for exercise, expressed using the decimal data type. In this case, the decimal declaration specifies a precision of three with a scale of two, meaning that any values in this column can have three digits at most, with two of those digits being to the right of the decimal point.
  • meals_perday: the dog hotel provides each dog with a certain number of meals each day. This column holds the number of meals each dog should receive per day as requested by their owner, and it uses int, an integer.
  • cups_permeal: this column lists how many cups of kibble each dog should receive per meal. Like the walk_distance column, this column is expressed as a decimal. However, this one has a scale of three with a precision of two, meaning values in this column can have up to three digits with two of those digits being to the right of the decimal point.

To ensure that the walker column only holds values that represent valid employee ID numbers, you decide to apply a foreign key constraint to the walker column that references the employees table’s emp_ID column. A foreign key constraint is a way to express a relationship between two tables by requiring that values in the column on which the foreign key has been applied must already exist in the column that it references. In the following example, the FOREIGN KEY constraint requires that any value added to the walker column in the dogs table must already exist in the employees table’s emp_ID column.

Create a table named dogs that has these columns with the following command:

  1. CREATE TABLE dogs (
  2. dog_id int UNIQUE,
  3. dog_name varchar(20),
  4. walker int,
  5. walk_distance decimal(3,2),
  6. meals_perday int,
  7. cups_permeal decimal(3,2),
  8. PRIMARY KEY (dog_id),
  9. FOREIGN KEY (walker)
  10. REFERENCES employees(emp_ID)
  11. );

Now you can load both tables with some sample data. Run the following INSERT INTO operation to add three rows of data representing three of your service’s employees to the employees table:

  1. INSERT INTO employees
  3. (1, 'Peter'),
  4. (2, 'Paul'),
  5. (3, 'Mary');

Then run the following operation to insert seven rows of data into the dogs table:

  1. INSERT INTO dogs
  3. (1, 'Dottie', 1, 5, 3, 1),
  4. (2, 'Bronx', 3, 6.5, 3, 1.25),
  5. (3, 'Harlem', 3, 1.25, 2, 0.25),
  6. (4, 'Link', 2, 2.75, 2, 0.75),
  7. (5, 'Otto', 1, 4.5, 3, 2),
  8. (6, 'Juno', 1, 4.5, 3, 2),
  9. (7, 'Zephyr', 3, 3, 2, 1.5);

With that, you’re ready to follow the rest of the guide and begin learning how to use views in SQL.

Understanding and Creating Views

Depending on the scenario, SQL queries can become surprisingly complex. Indeed, one of the main benefits of SQL is that it includes many different options and clauses that allow you to filter your data with a high level of granularity and specificity. If you have complex queries that you need to run frequently, having to continually write them out can quickly become frustrating. One way to work around these issues is by using views.

As mentioned in the introduction, views are virtual tables. This means that although a view is functionally similar to a table, it is a different type of structure since the view doesn’t hold any data of its own. Instead, it pulls in data from one or more base tables that actually hold the data. The only information about a view that a DBMS will store is the view’s structure. Views are sometimes called saved queries, because that’s essentially what they are: queries that have been saved under a specific name for convenient access.

(Video) SQL Views Tutorial | VIEWS in SQL Complete Tutorial

To better understand views, consider the following example scenario. Imagine that your dog care business is doing well and you need to print out a daily schedule for all your employees. The schedule should list each dog being cared for by the service, the employee who is assigned to care for them, the distance each dog should be walked every day, the number of meals each dog should be fed per day, and the amount of kibble each dog should get at every meal.

Using your SQL skills, you create a query with the sample data from the previous step to retrieve all of this information for the schedule. Note that this query includes the JOIN syntax in order to pull data from both the employees and dogs tables:

  1. SELECT emp_name, dog_name, walk_distance, meals_perday, cups_permeal
  2. FROM employees JOIN dogs ON emp_ID = walker;


+----------+----------+---------------+--------------+--------------+| emp_name | dog_name | walk_distance | meals_perday | cups_permeal |+----------+----------+---------------+--------------+--------------+| Peter | Dottie | 5.00 | 3 | 1.00 || Peter | Otto | 4.50 | 3 | 2.00 || Peter | Juno | 4.50 | 3 | 2.00 || Paul | Link | 2.75 | 2 | 0.75 || Mary | Bronx | 6.50 | 3 | 1.25 || Mary | Harlem | 1.25 | 2 | 0.25 || Mary | Zephyr | 3.00 | 2 | 1.50 |+----------+----------+---------------+--------------+--------------+7 rows in set (0.00 sec)

Say you have to run this query on a regular basis. This could become tedious to have to write out the query repeatedly, especially when it comes to longer and more complex query statements Also, if you had to make slight tweaks to the query or expand on it, it could be frustrating when troubleshooting mistakes with so many possibilities for syntax errors.

A view could be useful in cases like this, since a view is essentially a table derived from the results of a query.

To create a view, most RDBMSs use the following syntax:

Example CREATE VIEW syntax

CREATE VIEW view_nameASSELECT statement;

After the CREATE VIEW statement, you define a name for the view that you’ll use to refer to it later on. After the name, you enter the AS keyword and then the SELECT query whose output you want to save. The query you use to create your view can be any valid SELECT statement. The statement you include can query one or more base tables as long as you use the correct syntax.

Try creating a view using the previous example query. This CREATE VIEW operation names the view walking_schedule:

  1. CREATE VIEW walking_schedule
  2. AS
  3. SELECT emp_name, dog_name, walk_distance, meals_perday, cups_permeal
  4. FROM employees JOIN dogs
  5. ON emp_ID = walker;

Following that, you’ll be able to use and interact with this view like you would any other table.For instance, you could run the following query to return all the data held within the view:

  1. SELECT * FROM walking_schedule;


+----------+----------+---------------+--------------+--------------+| emp_name | dog_name | walk_distance | meals_perday | cups_permeal |+----------+----------+---------------+--------------+--------------+| Peter | Dottie | 5.00 | 3 | 1.00 || Peter | Otto | 4.50 | 3 | 2.00 || Peter | Juno | 4.50 | 3 | 2.00 || Paul | Link | 2.75 | 2 | 0.75 || Mary | Bronx | 6.50 | 3 | 1.25 || Mary | Harlem | 1.25 | 2 | 0.25 || Mary | Zephyr | 3.00 | 2 | 1.50 |+----------+----------+---------------+--------------+--------------+7 rows in set (0.00 sec)

Although this view is derived from two other tables, you won’t be able to query the view for any data from those tables unless it already exists in the view. The following query attempts to retrieve the walker column from the walking_schedule view, but this query will fail since the view doesn’t contain any columns with that name:

(Video) SQL VIEWS + Complex Queries, Cross Joins, Unions, and more! |¦| SQL Tutorial

  1. SELECT walker FROM walking_schedule;


ERROR 1054 (42S22): Unknown column 'walker' in 'field list'

This output returns an error message because the walker column is part of the dogs table, but was not included in the view you created.

You can also run queries that include aggregate functions that manipulate the data within a view. The following example uses the MAX aggregate function along with GROUP BY to find the longest distance each employee will have to walk on a given day:

  1. SELECT emp_name, MAX(walk_distance) AS longest_walks
  2. FROM walking_schedule GROUP BY emp_name;


+----------+---------------+| emp_name | longest_walks |+----------+---------------+| Peter | 5.00 || Paul | 2.75 || Mary | 6.50 |+----------+---------------+3 rows in set (0.00 sec)

As mentioned previously, another reason why views are useful is that you can use them to limit a database user’s access to only a view, rather than an entire table or database.

For example, say you hire an office manager to help you manage the schedule. You want them to have access to the schedule information, but not any other data in the database. To do this, you could create a new user account for them in your database:

  1. CREATE USER 'office_mgr'@'localhost' IDENTIFIED BY 'password';

Then, you could then grant this new user read access to the walking_schedule view, and only that view, with a GRANT statement like the following:

  1. GRANT SELECT ON views_db.walking_schedule to 'office_mgr'@'localhost';

Following this, anyone with access to the office_mgr MySQL user account would only be able to run SELECT queries on the walking_schedule view.

Changing and Deleting Views

If you add or change any of the data in one of the tables from which the view is derived, the relevant data will automatically be added or updated in the view. Run the following INSERT INTO command to add another row to the dogs table:

  1. INSERT INTO dogs VALUES (8, 'Charlie', 2, 3.5, 3, 1);

Then retrieve all the data from the walking_schedule view again:

  1. SELECT * FROM walking_schedule;


+----------+----------+---------------+--------------+--------------+| emp_name | dog_name | walk_distance | meals_perday | cups_permeal |+----------+----------+---------------+--------------+--------------+| Peter | Dottie | 5.00 | 3 | 1.00 || Peter | Otto | 4.50 | 3 | 2.00 || Peter | Juno | 4.50 | 3 | 2.00 || Paul | Link | 2.75 | 2 | 0.75 || Paul | Charlie | 3.50 | 3 | 1.00 || Mary | Bronx | 6.50 | 3 | 1.25 || Mary | Harlem | 1.25 | 2 | 0.25 || Mary | Zephyr | 3.00 | 2 | 1.50 |+----------+----------+---------------+--------------+--------------+8 rows in set (0.00 sec)

This time, there’s another row in the query’s result set reflecting the data you added to the dogs table.

(Video) Views in sql server Part 39

However, the view is still pulling the same data from the same base tables, so this operation did not change the view itself.

Many RDBMSs allow you to update the structure of the view after you create it by using the CREATE OR REPLACE VIEW syntax:


CREATE OR REPLACE VIEW view_nameASnew SELECT statement

With this syntax, if a view with the name view_name already exists, the database system will update it so that it represents the data returned by the new SELECT statement. If a view by that name doesn’t already exist, then the DBMS will create a new one.

Say you wanted to change the walking_schedule view so that instead of listing how many cups of food per meal each dog eats, it listed how much total food each dog ate throughout the day. You can change the view with the following command:

  1. CREATE OR REPLACE VIEW walking_schedule
  2. AS
  3. SELECT emp_name, dog_name, walk_distance, meals_perday, (cups_permeal * meals_perday) AS total_kibble
  4. FROM employees JOIN dogs ON emp_ID = walker;

Now when you query this view, the result set will reflect the view’s new data:

  1. SELECT * FROM walking_schedule;


+----------+----------+---------------+--------------+--------------+| emp_name | dog_name | walk_distance | meals_perday | total_kibble |+----------+----------+---------------+--------------+--------------+| Peter | Dottie | 5.00 | 3 | 3.00 || Peter | Otto | 4.50 | 3 | 6.00 || Peter | Juno | 4.50 | 3 | 6.00 || Paul | Link | 2.75 | 2 | 1.50 || Paul | Charlie | 3.50 | 3 | 3.00 || Mary | Bronx | 6.50 | 3 | 3.75 || Mary | Harlem | 1.25 | 2 | 0.50 || Mary | Zephyr | 3.00 | 2 | 3.00 |+----------+----------+---------------+--------------+--------------+8 rows in set (0.00 sec)

Like most other structures one can create in SQL, you can delete views using the DROP syntax:

Example DROP VIEW syntax

DROP VIEW view_name;

For instance, if you ever wanted to drop the walking_schedule view, you’d do so with the following command:

  1. DROP VIEW walking_schedule;

This removes the walking_schedule view from your database, but none of the view’s data will be deleted unless you remove it from the base tables.


By reading this guide, you learned what SQL views are, how to create, query, change, and delete them from a database. You also learned why views can be useful, and created a MySQL user who could only read data from the sample view created in this guide.

(Video) View in Database | Oracle, SQL Server Views | Types of Views

While the commands from our examples should work on most relational databases, be aware that every SQL database uses its own unique implementation of the language. You should consult your DBMS’s official documentation for a more complete description of each command and their full sets of options.

If you’d like to learn more about working with SQL, we encourage you to check out the other tutorials in this series on How To Use SQL.


How To Use Views in SQL | DigitalOcean? ›

In SQL, a view is a virtual table based on the result-set of an SQL statement. A view contains rows and columns, just like a real table. The fields in a view are fields from one or more real tables in the database.

How to use view query in SQL? ›

In SQL, a view is a virtual table based on the result-set of an SQL statement. A view contains rows and columns, just like a real table. The fields in a view are fields from one or more real tables in the database.

How does a view work in SQL? ›

A VIEW in SQL Server is like a virtual table that contains data from one or multiple tables. It does not hold any data and does not exist physically in the database. Similar to a SQL table, the view name should be unique in a database. It contains a set of predefined SQL queries to fetch data from the database.

How to get SQL query from view? ›

In Object Explorer, expand the database that contains the view to which you want to view the properties, and then expand the Views folder. Right-click the view of which you want to view the properties and select View Dependencies. Select Objects that depend on [view name] to display the objects that refer to the view.

How can we insert data into a view? ›

You can insert data through a single-table view if you have the Insert privilege on the view. To do this, the defining SELECT statement can select from only one table, and it cannot contain any of the following components: DISTINCT keyword.

Why do we use views in SQL? ›

Views are generally used to focus, simplify, and customize the perception each user has of the database. Views can be used as security mechanisms by letting users access data through the view, without granting the users permissions to directly access the underlying base tables of the view.

Can you run query on a view? ›

You can also run queries that include aggregate functions that manipulate the data within a view.

Are views faster than tables? ›

Speed. Because you store data in a table on the database, it can be quicker to access. Once you open the application, you can quickly access the information you seek. Data in a view can take longer to access because you have to run a query first.

What is the difference between views and tables in SQL? ›

A table consists of rows and columns to store and organized data in a structured format, while the view is a result set of SQL statements. A table is structured with columns and rows, while a view is a virtual table extracted from a database.

How are views stored in SQL? ›

The view is a query stored in the data dictionary, on which the user can query just like they do on tables. It does not use the physical memory, only the query is stored in the data dictionary. It is computed dynamically, whenever the user performs any query on it.

What are the two types of views in SQL? ›

There are two types of views in the SQL Server, namely System Defined Views and User Defined Views.

How to get all tables from view in SQL? ›

The easiest way to find all tables in SQL is to query the INFORMATION_SCHEMA views. You do this by specifying the information schema, then the “tables” view.

Does view store data in SQL? ›

A view (virtual table) is built on top of the concrete table(s) it fetches data from and does not store any data of its own in the database. A view only contains the SQL query that is used to fetch the data.

Why would we want to use views? ›

Views are virtual tables that can be a great way to optimize your database experience. Not only are views good for defining a table without using extra storage, but they also accelerate data analysis and can provide your data extra security.

Can we edit data in view? ›

To modify table data through a view. In Object Explorer, expand the database that contains the view and then expand Views. Right-click the view and select Edit Top 200 Rows. You may need to modify the SELECT statement in the SQL pane to return the rows to be modified.

Can you write data to a view? ›

You cannot insert data into a view. Instead you must insert the data into the table(s) on which the view is built.

What are the disadvantages of using views in SQL? ›

Although there are many advantages to views, the main disadvantage to using views rather than real tables is performance degradation. Because views only create the appearance of a table, not a real table, the query processor must translate queries against the view into queries against the underlying source tables.

What is view with example? ›

A view is a subset of a database that is generated from a user query and gets stored as a permanent object. In a structured query language (SQL) database, for example, a view becomes a type of virtual table with filtered rows and columns that mimic those of the original database.

Why not to use views in SQL? ›

Views are not the same as tables in SQL because views do not store any existing data on memory, unlike tables. Whenever you are interacting with views in SQL, you are essentially running an unknown backend query that obtains relevant information stored in tables that you may not have direct access to it.

Can a SQL View call a stored procedure? ›

You cannot call a stored proc from inside a view. It is not supported. However you can make views call other views, or table-valued user-defined functions. For the latter you must make sure that you're using inline functions.

How do I edit a view query in SQL? ›

Right-click on the view you wish to modify and select Design. In the diagram pane of the query designer, make changes to the view in one or more of the following ways: Select or clear the check boxes of any elements you wish to add or remove.

Why use a view instead of a table? ›

Views can provide advantages over tables: Views can represent a subset of the data contained in a table. Consequently, a view can limit the degree of exposure of the underlying tables to the outer world: a given user may have permission to query the view, while denied access to the rest of the base table.

Can we create tables from views? ›

CREATE TABLE yourTableName AS SELECT yourColumnName1,yourColumnName2,yourColumnName3,........ N from yourViewName; To run the above query, first you need to create a table and after that you need to create a view on that table. After that run the query.

Can a table have multiple views? ›

You can define multiple views of a table, and add a chart, if required. You can define variants for specific selections of data on the user interface, for example, based on filter settings. In the definition dialog, these variants are called views, however, the feature is called variant management.

How to remove duplicates in SQL? ›

One of the easiest ways to remove duplicate data in SQL is by using the DISTINCT keyword. You can use the DISTINCT keyword in a SELECT statement to retrieve only unique values from a particular column.

How many tables can be joined to create a view? ›

You can create a view that combines data from two or more tables by naming more than one table in the FROM clause.

What are advantages and disadvantages of database view? ›

What are the advantages and disadvantages of views in a database?
  • Views doesn't store data in a physical location.
  • View can be use to hide some of the columns from the table.
  • Views can provide Access Restriction, since data insertion, update and deletion is not possible on the view.

Are views permanent in SQL? ›

A view is permanent, but it is a view, not a table.

Does views increase performance in SQL? ›

Views make queries faster to write, but they don't improve the underlying query performance.

Do views in SQL occupy memory? ›

A view is a virtual table in SQL that functions similarly to a standard table, but does not need to be physically stored, i.e. it is only stored in memory and does not take up actual storage space.

How do I create a view in SQL for multiple tables? ›

To create a view, a user must have the appropriate system privilege according to the specific implementation. CREATE VIEW view_name AS SELECT column1, column2..... FROM table_name WHERE [condition]; You can include multiple tables in your SELECT statement in a similar way as you use them in a normal SQL SELECT query.

What are the two main views of data in a database? ›

Logical level (conceptual level) View level (external level)

How to compare two views in SQL? ›

Select a comparison key for each table or view. To match rows in the two data sources, Data Compare for SQL Server requires a comparison key for each table or view. The tool automatically selects a comparison key if: Tables contain a matching primary key, unique index, or unique constraint.

How do I count all rows in SQL view? ›

SQL SELECT COUNT(*) function

SQL SELECT statement can be used along with COUNT(*) function to count and display the data values. The COUNT(*) function represents the count of all rows present in the table (including the NULL and NON-NULL values).

How do you check if a table is a view? ›

In SQL Server you can use the OBJECTPROPERTY() function to check an object's type. More specifically, you can check whether it is or isn't a specific type. For example, the IsTable property tells you whether or not it's a table, the IsView property tells you whether or not it's a view, etc.

How do I get a list of tables used in a view? ›

To find all of the SQL Server database views where a table is used, just apply a filter criteria on table_name column of the information schema view INFORMATION_SCHEMA.

Is view temporary in SQL? ›

A view exists only for a single query. Each time you use the name of a view, its table is recreated from existing data. A temporary table exists for the entire database session in which it was created. A view is automatically populated with the data retrieved by the query that defines it.

How to use view query in MySQL? ›

The basic syntax for creating a view in MySQL is as follows: CREATE VIEW [db_name.] view_name [(column_list)] AS select-statement; [db_name.] is the name of the database where your view will be created; if not specified, the view will be created in the current database.

How to check all views in SQL? ›

4 Ways to List All Views in a SQL Server Database
  1. Option 1 – The VIEWS Information Schema View. You can use the VIEWS information schema view to get a list of all user-defined views in a database. ...
  2. Option 2 – The sys.views System Catalog View. ...
  3. Option 3 – The sys.objects System Catalog View.
Jan 23, 2020

How to execute query in view in SQL Server? ›

How to execute a view in SQL Server Management Studio
  1. First, run SQL Server Management Studio and connect to the required database instance.
  2. Next, from the Object Explorer, first, expand the required Databases directory.
  3. Then, expad the Views directory under the database.
Dec 24, 2021

How to get data from views in MySQL? ›

MySQL Views

A view contains rows and columns, just like a real table. The fields in a view are fields from one or more real tables in the database. You can add SQL statements and functions to a view and present the data as if the data were coming from one single table. A view is created with the CREATE VIEW statement.

How many types of SQL views are there? ›

There are two types of views in the SQL Server, namely System Defined Views and User Defined Views.

How to create a view in SQL Server? ›

Use SQL Server Management Studio

Right-click the Views folder, then select New View.... In the Add Table dialog box, select the element or elements that you want to include in your new view from one of the following tabs: Tables, Views, Functions, and Synonyms. Select Add, then select Close.


1. SQL course - SQL-view in Microsoft Access (lesson 2)
(Jalayer Academy)
2. How to Use Views in SQL Server
(taurius litvinavicius)
3. 40. how to use Views in SQL
4. Advanced Queries – Introduction to SQL with Paul Buffa, Part 4
5. Use SQL Views to Improve your Power BI Experience
(Matador Software)
6. Why you should use Views instead of Table - Power BI Desktop Tips and Tricks (32/100)
(Analytics with Nags)


Top Articles
Latest Posts
Article information

Author: Arielle Torp

Last Updated: 08/10/2023

Views: 5970

Rating: 4 / 5 (61 voted)

Reviews: 92% of readers found this page helpful

Author information

Name: Arielle Torp

Birthday: 1997-09-20

Address: 87313 Erdman Vista, North Dustinborough, WA 37563

Phone: +97216742823598

Job: Central Technology Officer

Hobby: Taekwondo, Macrame, Foreign language learning, Kite flying, Cooking, Skiing, Computer programming

Introduction: My name is Arielle Torp, I am a comfortable, kind, zealous, lovely, jolly, colorful, adventurous person who loves writing and wants to share my knowledge and understanding with you.