Tutorial: Inserting Records and DataFrames Into a SQL Database (2022)

August 12, 2019

Tutorial: Inserting Records and DataFrames Into a SQL Database (1)

Learn to insert data into SQL databases like a pro!

One of the key roles of a data scientist is to extract patterns and insights from raw data. Since much of the world’s government and corporate data is organized in relational databases, it makes sense that data scientists need to know how to work with these database structures. Writing SQL queries to insert, extract, and filter data in databases is a key skill for anyone interested in data analytics or data science.

SQL (Structured Query Language) is based on E. F. Codd’s Relational model and algebra to manage the relational databases. It’s a database query language used to create, insert, query, and manipulate the relational database and used by a large number of applications.

Although it has been around for decades, learning SQL is still a critical skill for modern data scientists, and really anyone who works with data at all, because SQL is used in all kinds of relational database software, including MySQL, SQL Server, Oracle, and PostgreSQL.

In this tutorial, we’ll learn about SQL insertion operations in detail. Here is the list of topics that we will learn in this tutorial:

  • SQL Insertion
  • Inserting records into a database
  • Inserting Pandas DataFrames into a database using the insert command
  • Inserting Pandas DataFrames into a database using the to_sql() command
  • Reading records from a database
  • Updating records in a database

Want to reach a higher level of SQL skill? Sign up for free and check out Dataquest’s SQL courses for thorough, interactive lessons on all the SQL skills you’ll need for data science.

SQL Insertion

SQL Insertion is an essential operation for data workers to understand. Inserting missing data or adding new data is a major part of the data cleaning process on most data science projects.

Insertion is also how most data gets into databases in the first place, so it’s important anytime you’re collecting data, too. When your company gets new data on a customer, for example, chances are than a SQL insert will be how that data gets into your existing customer database.

In fact, whether or not you’re aware of it, data is flowing into databases using SQL inserts all the time! When you fill out a marketing survey, complete a transaction, file a government form online, or do any of thousands of other things, your data is likely being inserted into a database somewhere using SQL.

Let’s dive into how we can actually use SQL to insert data into a database. We can insert data row by row, or add multiple rows at a time.

Inserting records into a database

In SQL, we use the INSERT command to add records/rows into table data. This command will not modify the actual structure of the table we’re inserting to, it just adds data.

Let’s imagine we have a data table like the one below, which is being used to store some information about a company’s employees.

Now, let’s imagine we have new employees we need to put into the system.

(Video) Inserting DataFrame to MySQL database table by using to_sql() from Excel or CSV sources

This employee table could be created using the CREATE TABLE command, so we could use that command to create an entirely new table. But it would be very inefficient to create a completely new table every time we want to add data! Instead, let’s use the INSERT command to add the new data into our existing table.

Here’s the basic syntax for using INSERT in SQL:

We start with the command INSERT INTO followed by the name of table into which we’d like to insert data. After the table name, we list the columns of new data we’re inserting column by column, inside parentheses. Then, on the next line, we used the command VALUES along with the values we want to insert (in sequence inside parentheses.

So for our employee table, if we were adding a new employee named Kabir, our INSERT command might look like this:

Inserting Records Into a Database From Python

Since we’re often working with our data in Python when doing data science, let’s insert data from Python into a MySQL database. This is a common task that has a variety of applications in data science.

We can send and receive data to a MySQL database by establishing a connection between Python and MySQL. There are various ways to establish this connection; here, we will use pymysql for database connectivity.

Here are the broad steps we’ll need to work through to get pymysql connected, insert our data, and then extract the data from MySQL:

Let’s walk through this process step by step.

Step 1: Import the pymysql module.

# Import pymysql moduleimport pymysql

Step 2: Create connection a to the MySQL database

Create a connection using pymysql‘s connect() function with the parameters host, user, database name, and password.

(The parameters below are for demonstration purposes only; you’ll need to fill in the specific access details required for the MySQL database you’re accessing.)

# Connect to the databaseconnection = pymysql.connect(host='localhost', user='root', password='12345', db='employee')

Step 3: Create a cursor using the cursor() function.

This will allow us to execute the SQL query once we’ve written it.

cursor = connection.cursor()

Step 4: Execute the required SQL query

Commit the changes using the commit() function, and check the inserted records. Note that we can create a variable called sql, assign our query’s syntax to it, and then pass sql and the specific data we want to insert as arguments to cursor.execute().

Then, we’ll commit these changes using commit().

# Create a new recordsql = "INSERT INTO `employee` (`EmployeeID`, `Ename`, `DeptID`, `Salary`, `Dname`, `Dlocation`) VALUES (%s, %s, %s, %s, %s, %s)"# Execute the querycursor.execute(sql, (1008,'Kabir',2,5000,'IT','New Delhi'))# the connection is not autocommited by default. So we must commit to save our changes.connection.commit()

Let’s do a quick check to see if the record we wanted to insert has actually been inserted.

(Video) Pandas Dataframes and SQL [How to write dataframes into a sql database/get sql table to dataframe]

We can do this by querying the database for the entire contents of employee, and then fetching and printing those results.

# Create a new query that selects the entire contents of `employee`sql = "SELECT * FROM `employee`"cursor.execute(sql)# Fetch all the records and use a for loop to print them one line at a timeresult = cursor.fetchall()for i in result: print(i)
(1001, 'John', 2, 4000, 'IT', 'New Delhi') (1002, 'Anna', 1, 3500, 'HR', 'Mumbai') (1003, 'James', 1, 2500, 'HR', 'Mumbai') (1004, 'David', 2, 5000, 'IT', 'New Delhi') (1005, 'Mark', 2, 3000, 'IT', 'New Delhi') (1006, 'Steve', 3, 4500, 'Finance', 'Mumbai') (1007, 'Alice', 3, 3500, 'Finance', 'Mumbai') (1008, 'Kabir', 2, 5000, 'IT', 'New Delhi')

It worked! Above, we can see the new record has been inserted and is now the final row in our MySQL database.

Step 5: Close the database connection

Now that we’re done, we should close the database connection using close() method.

# Close the connectionconnection.close()

Of course, it would be better to write this code in a way that could better handle exceptions and errors. We can do this using try to contain the body of our code and except to print errors if any arise. Then, we can use finally to close the connection once we’re finished, regardless of whether try succeeded or failed.

Here’s what that looks like all together:

import pymysqltry: # Connect to the database connection = pymysql.connect(host='localhost', user='root', password='12345', db='employee') cursor=connection.cursor() # Create a new record sql = "INSERT INTO `employee` (`EmployeeID`, `Ename`, `DeptID`, `Salary`, `Dname`, `Dlocation`) VALUES (%s, %s, %s, %s, %s, %s)" cursor.execute(sql, (1009,'Morgan',1,4000,'HR','Mumbai')) # connection is not autocommit by default. So we must commit to save our changes. connection.commit() # Execute query sql = "SELECT * FROM `employee`" cursor.execute(sql) # Fetch all the records result = cursor.fetchall() for i in result: print(i)except Error as e: print(e)finally: # close the database connection using close() method. connection.close()
((1001, 'John', 2, 4000, 'IT', 'New Delhi'), (1002, 'Anna', 1, 3500, 'HR', 'Mumbai'), (1003, 'James', 1, 2500, 'HR', 'Mumbai'), (1004, 'David', 2, 5000, 'IT', 'New Delhi'), (1005, 'Mark', 2, 3000, 'IT', 'New Delhi'), (1006, 'Steve', 3, 4500, 'Finance', 'Mumbai'), (1007, 'Alice', 3, 3500, 'Finance', 'Mumbai'), (1008, 'Kabir', 2, 5000, 'IT', 'New Delhi'), (1009, 'Morgan', 1, 4000, 'HR', 'Mumbai'), (1009, 'Morgan', 1, 4000, 'HR', 'Mumbai'))

Inserting Pandas DataFrames Into Databases Using INSERT

When working with data in Python, we’re often using pandas, and we’ve often got our data stored as a pandas DataFrame. Thankfully, we don’t need to do any conversions if we want to use SQL with our DataFrames; we can directly insert a pandas DataFrame into a MySQL database using INSERT.

Once again, we’ll take it step-by-step.

Step 1: Create DataFrame using a dictionary

We could also import data from a CSV or create a DataFrame in any number of other ways, but for the purposes of this example, we’re just going to create a small DataFrame that saves the titles and prices of some data science texbooks.

# Import pandasimport pandas as pd# Create dataframedata = pd.DataFrame({ 'book_id':[12345, 12346, 12347], 'title':['Python Programming', 'Learn MySQL', 'Data Science Cookbook'], 'price':[29, 23, 27]})data
012345Python Programming29
112346Learn MySQL23
212347Data Science Cookbook27

Step 2: Create a table in our MySQL database

Before inserting data into MySQL, we’re going to to create a book table in MySQL to hold our data. If such a table already existed, we could skip this step.

We’ll use a CREATE TABLE statement to create our table, follow that with our table name (in this case, book_details), and then list each column and its corresponding datatype.

Tutorial: Inserting Records and DataFrames Into a SQL Database (2)

Step 3: Create a connection to the database

Once we’ve created that table, we can once again create a connection to the database from Python using pymysql.

import pymysql# Connect to the databaseconnection = pymysql.connect(host='localhost', user='root', password='12345', db='book')# create cursorcursor=connection.cursor()

Step 4: Create a column list and insert rows

Next, we’ll create a column list and insert our dataframe rows one by one into the database by iterating through each row and using INSERT INTO to insert that row’s values into the database.

(Video) Python Bulk Insert Data From excel to sql server | Dataframe to SQL Table | Sqlalchemy Engine

(It is also possible to insert the entire DataFrame at once, and we’ll look at a way of doing that in the next section, but first let’s look at how to do it row-by-row).

# creating column list for insertioncols = "`,`".join([str(i) for i in data.columns.tolist()])# Insert DataFrame recrds one by one.for i,row in data.iterrows(): sql = "INSERT INTO `book_details` (`" +cols + "`) VALUES (" + "%s,"*(len(row)-1) + "%s)" cursor.execute(sql, tuple(row)) # the connection is not autocommitted by default, so we must commit to save our changes connection.commit()

Step 5: Query the database to check our work

Again, let’s query the database to make sure that our inserted data has been saved correctly.

# Execute querysql = "SELECT * FROM `book_details`"cursor.execute(sql)# Fetch all the recordsresult = cursor.fetchall()for i in result: print(i)
(12345, 'Python Programming', 29) (12346, 'Learn MySQL', 23) (12347, 'Data Science Cookbook', 27)

Once we’re satisfied that everything looks right, we can close the connection.


Inserting Pandas DataFrames into a Database Using the to_sql() Function

Now let’s try to do the same thing — insert a pandas DataFrame into a MySQL database — using a different technique. This time, we’ll use the module sqlalchemy to create our connection and the to_sql() function to insert our data.

This approach accomplishes the same end result in a more direct way, and allows us to add a whole dataframe to a MySQL database all at once.

# Import modulesimport pandas as pd# Create dataframedata=pd.DataFrame({ 'book_id':[12345,12346,12347], 'title':['Python Programming','Learn MySQL','Data Science Cookbook'], 'price':[29,23,27]})data
012345Python Programming29
112346Learn MySQL23
212347Data Science Cookbook27

Import the module sqlalchemy and create an engine with the parameters user, password, and database name. This is how we connect and log in to the MySQL database.

# import the modulefrom sqlalchemy import create_engine# create sqlalchemy engineengine = create_engine("mysql+pymysql://{user}:{pw}@localhost/{db}" .format(user="root", pw="12345", db="employee"))

Once we’re connected, we can export the whole DataFrame to MySQL using the to_sql() function with the parameters table name, engine name, if_exists, and chunksize.

We’ll take a closer look at what each of these parameters refers to in a moment, but first, take a look at how much simpler it is to insert a pandas DataFrame into a MySQL database using this method. We can do it with just a single line of code:

# Insert whole DataFrame into MySQLdata.to_sql('book_details', con = engine, if_exists = 'append', chunksize = 1000)

Now let’s take a closer look at what each of these parameters is doing in our code.

  • book_details is the name of table into which we want to insert our DataFrame.
  • con = engine provides the connection details (recall that we created engine using our authentication details in the previous step).
  • if_exists = 'append' checks whether the table we specified already exists or not, and then appends the new data (if it does exist) or creates a new table (if it doesn’t).
  • chunksize writes records in batches of a given size at a time. By default, all rows will be written at once.

Reading Records from a Database

Once we’ve used SQL inserts to get our data into the database, we’ll want to be able to read it back! So far in this tutorial, we’ve checked our SQL inserts by simply printing the entire database, but obviously this is not a viable option with larger databases where you’d be printing thousands of rows (or more). So let’s take a more in-depth look at how we can read back the records we’ve created or inserted into our SQL database.

We can read records from a SQL database using the SELECT command. We can select specific columns, or use * to select everything from a given table. We can also select to return only records that meet a particular condition using the WHERE command.

Here’s how the syntax for these commands looks:

Tutorial: Inserting Records and DataFrames Into a SQL Database (3)

(Video) Python Pandas Tutorial: Importing Bulk CSVs Data Into SQL Server Using Python #17

We start with a SELECT clause, followed by list of columns, or * if we want to select all columns.Then we’ll use a FROM clause to name the table we’d like to look at. WHERE can be used to filter the records and followed by a filter condition, and we can also use ORDER BY to sort the records. (The WHERE and ORDER BY clauses are optional).

With larger databases, WHERE is useful for returning only the data we want to see. So if, for example, we’ve just inserted some new data about a particular department, we could use WHERE to specify the department ID in our query, and it would return only the records with a department ID that matches the one we specified.

Compare, for example, the results of these two queries using our employee table from earlier. In the first, we’re returning all the rows. In the second, we’re getting back only the rows we’ve asked for. This may not make a big difference when our table has seven rows, but when you’re working with seven thousand rows, or even seven million, using WHERE to return only the results you want is very important!

If we want to do this from within Python, we can use the same script we used earlier in this tutorial to query these records. The only difference is that we’ll tell pymysql to execute the SELECT command rather than the INSERT command we used earlier.

# Import moduleimport pymysql# create connectionconnection = pymysql.connect(host='localhost', user='root', password='12345', db='employee')# Create cursormy_cursor = connection.cursor()# Execute Querymy_cursor.execute("SELECT * from employee")# Fetch the recordsresult = my_cursor.fetchall()for i in result: print(i)# Close the connectionconnection.close()
(1001, 'John', 2, 4000, 'IT', 'New Delhi') (1002, 'Anna', 1, 3500, 'HR', 'Mumbai') (1003, 'James', 1, 2500, 'HR', 'Mumbai') (1004, 'David', 2, 5000, 'IT', 'New Delhi') (1005, 'Mark', 2, 3000, 'IT', 'New Delhi') (1006, 'Steve', 3, 4500, 'Finance', 'Mumbai') (1007, 'Alice', 3, 3500, 'Finance', 'Mumbai') (1008, 'Kabir', 2, 5000, 'IT', 'New Delhi') (1009, 'Morgan', 1, 4000, 'HR', 'Mumbai') (1009, 'Morgan', 1, 4000, 'HR', 'Mumbai')

Above, we’ve selected and printed the entire database, but if we wanted to use WHERE to make a more careful, limited selection, the approach is the same:

my_cursor.execute("SELECT * FROM employee WHERE DeptID=2")

Updating Records in the Database

Often, we’ll need to modify the records in the table after creating them.

For example, imagine that an employee in our employee table got a promotion. We’d want to update their salary data. The INSERT INTO command won’t help us here, because we don’t want to add an entirely new row.

To modify existing records in the table, we need to use the UPDATE command. UPDATE is used to change the contents of existing records. We can specify specific columns and values to change using SET, and we can also make conditional changes with WHERE to apply those changes only to rows that meet that condition.

Tutorial: Inserting Records and DataFrames Into a SQL Database (4)

Now, let’s update the records from our employee table and display the results. In this case, let’s say David got the promotion — we’ll write a query using UPDATE that sets Salary to 6000 only in columns where the employee ID is 1004 (David’s ID).

Be careful — without the WHERE clause, this query would update every record in the table, so don’t forget that!

After executing the above query, the updated table would look like this:


In this tutorial, we’ve taken a look at SQL inserts and how to insert data into MySQL databases from Python. We also learned to insert Pandas DataFrames into SQL databases using two different methods, including the highly efficient to_sql() method.

Of course, this is just the tip of the iceberg when it comes to SQL queries. If you really want to become a master of SQL, sign up for free and dive into one of Dataquest’s interactive SQL courses to get interactive instruction and hands-on experience writing all the queries you’ll need to do productive, professional data science work.

(Video) How to insert records to your Microsoft SQL Server database using Python

Also check out some of our other free SQL-related resources:

  • Do you need a SQL certification?
  • SQL interview questions to prep for job interviews
  • Our SQL cheat sheet

beginnerSQLsql inserttutorialTutorials


How do you create a DataFrame in SQL query? ›

Steps to convert SQL to DataFrame in Pandas
  1. Create MySQL Database and Table.
  2. Import Pandas and pymysql package.
  3. Connect Python to MySQL with pymysql. connect() function.
  4. Read the SQL query.
  5. Convert that variable values into DataFrame using pd. DataFrame() function.
Jun 3, 2022

What is the correct command to insert data to database? ›

The general syntax for inserting data in SQL looks like this:
  1. INSERT INTO table_name.
  2. ( column1 , column2 , . . . columnN )
  3. VALUES.
  4. ( value1 , value2 , . . . valueN );
Sep 15, 2020

How do I insert data into a SQL database using Python? ›

Steps to Insert Values into SQL Server Table using Python
  1. Step 1: Install the Pyodbc Package. ...
  2. Step 2: Connect Python to SQL Server. ...
  3. Step 3: Insert values into SQL Server table using Python. ...
  4. Step 4: Verify the results.
Oct 1, 2021

How can I make SQL server insert query faster? ›

The easiest solution is to simply batch commit. Eg. commit every 1000 inserts, or every second. This will fill up the log pages and will amortize the cost of log flush wait over all the inserts in a transaction.

How do I query a SQL database in Python? ›

Steps to fetch rows from a MySQL database table
  1. Connect to MySQL from Python. ...
  2. Define a SQL SELECT Query. ...
  3. Get Cursor Object from Connection. ...
  4. Execute the SELECT query using execute() method. ...
  5. Extract all rows from a result. ...
  6. Iterate each row. ...
  7. Close the cursor object and database connection object.
Mar 9, 2021

How do I run a SQL query in pandas? ›

Use pandasql to Run SQL Queries in Python

We will import the sqldf method from the pandasql module to run a query. Then we will call the sqldf method that takes two arguments. The first argument is a SQL query in string format. The second argument is a set of session/environment variables ( globals() or locals() ).

How do I write pandas Dataframe in MySQL? ›

Create a dataframe by calling the pandas dataframe constructor and passing the python dict object as data. Invoke to_sql() method on the pandas dataframe instance and specify the table name and database connection. This creates a table in MySQL database server and populates it with the data from the pandas dataframe.

How do you create a data frame? ›

To create a dataframe, we need to import pandas. Dataframe can be created using dataframe() function. The dataframe() takes one or two parameters. The first one is the data which is to be filled in the dataframe table.

What is a DataFrame in Spark and how is it different from a SQL table? ›

In Spark, a DataFrame is a distributed collection of data organized into named columns. It is conceptually equivalent to a table in a relational database or a data frame in R/Python, but with richer optimizations under the hood.

How do you read SQL queries? ›

How to Understand Long and Complex SQL Queries
  1. STEP 1) Big Picture First! ...
  2. STEP 2) Focus on the Final Columns First! ...
  3. STEP 3) Understand the Final GROUP BY and WHERE Clauses. ...
  4. STEP 4) Look at the Final JOINs. ...
  5. STEP 5) Look at CTEs and Subqueries in Reverse Order. ...
  6. STEP 6) Time to Understand CTEs and Subqueries.

What is the syntax for insert in SQL? ›

There are two basic syntax of INSERT INTO statement is as follows: INSERT INTO TABLE_NAME (column1, column2, column3,... columnN)] VALUES (value1, value2, value3,... valueN);

Which of the following is correct format to insert data in table? ›

If we want to create a data, we're going to use the SQL keyword, “Insert”. The general format is the INSERT INTO SQL statement followed by a table name, then the list of columns, and then the values that you want to use the SQL insert statement to add data into those columns.

Which SQL statement is used to insert a new data in a database? ›

The INSERT INTO statement is used to insert new records in a table.

How do you insert multiple rows in SQL using Python? ›

What if you want to insert multiple rows into a table in a single insert query from the Python application. Use the cursor's executemany() function to insert multiple records into a table. Syntax of the executemany() method.

How do I insert data into a mysql database from a text file? ›

mysql> LOAD DATA LOCAL INFILE '/path/pet. txt' INTO TABLE pet; If you created the file on Windows with an editor that uses \r\n as a line terminator, you should use this statement instead: mysql> LOAD DATA LOCAL INFILE '/path/pet.

How do you pass a variable in an insert statement in SQL? ›

You can divide the following query into three parts.
  1. Create a SQL Table variable with appropriate column data types. We need to use data type TABLE for table variable.
  2. Execute a INSERT INTO SELECT statement to insert data into a table variable.
  3. View the table variable result set.
Apr 12, 2019

How can I improve my insert performance? ›

To optimize insert speed, combine many small operations into a single large operation. Ideally, you make a single connection, send the data for many new rows at once, and delay all index updates and consistency checking until the very end.

How do I add 10000 rows in SQL? ›

To add up the rows, the user needs to use insert statement.
  1. Syntax :
  2. Example – A table named student must have values inserted into it. It has to be done as follows:
  3. Output –
  4. Output –
  5. insert multiple rows : A table can store upto 1000 rows in one insert statement. ...
  6. Syntax :
  7. Example – Consider a table student. ...
  8. Output –
Aug 5, 2020

Which is faster update or insert? ›

An insert and delete will not always be faster than a single update, in much the same way that separate operations will not always be faster than a single MERGE (though that is probably even more common).

How do I learn SQL? ›

How to learn SQL for free
  1. Watch a Video. Visual learners rejoice! ...
  2. Walk through an Online SQL Tutorial‍ ...
  3. Take a Free Class to Learn SQL‍ ...
  4. Consult a Resource‍ ...
  5. Consult a Thread‍ ...
  6. Try a free bootcamp‍ ...
  7. Earn a SQL certification‍ ...
  8. Install a Free SQL Database System‍
Aug 2, 2021

What language is SQL? ›

SQL stands for Structured Query Language, which is a programming language used to communicate with relational databases. The acronym is pronounced like the word sequel, but some people will just use the three letters S, Q, and L.

Is SQL easier than Python? ›

If we look at it as a language, then SQL is much easier as compared to Python because the syntax is smaller, and there are pretty few concepts in SQL. On the other hand, if you look at it as a tool, then SQL is tougher than coding in Python.

How do I write pandas Dataframe in MySQL? ›

Create a dataframe by calling the pandas dataframe constructor and passing the python dict object as data. Invoke to_sql() method on the pandas dataframe instance and specify the table name and database connection. This creates a table in MySQL database server and populates it with the data from the pandas dataframe.

How do I query a SQL database in Python? ›

Steps to fetch rows from a MySQL database table
  1. Connect to MySQL from Python. ...
  2. Define a SQL SELECT Query. ...
  3. Get Cursor Object from Connection. ...
  4. Execute the SELECT query using execute() method. ...
  5. Extract all rows from a result. ...
  6. Iterate each row. ...
  7. Close the cursor object and database connection object.
Mar 9, 2021

What is the difference between PyODBC and Sqlalchemy? ›

PyODBC allows you connecting to and using an ODBC database using the standard DB API 2.0. SQL Alchemy is a toolkit that resides one level higher than that and provides a variety of features: Object-relational mapping (ORM) Query constructions.

How do I rename a column in pandas? ›

Method 1: Using rename() function

One way of renaming the columns in a Pandas Dataframe is by using the rename() function. This method is quite useful when we need to rename some selected columns because we need to specify information only for the columns which are to be renamed.


1. Insert pandas Dataframe into Oracle database using python cx_Oracle
(Learning Software Skills)
2. Import Records From CSV File (or any data file) to SQL Server (or any database system) With Python
(Jie Jenn)
3. Export DataFrame into MySQL|PJ Academy
(PJ Academy)
4. How to Connect Python to SQL Database - CREATE, SELECT and INSERT Data
(Kindson The Genius)
5. How to IMPORT Excel file (CSV) to MySQL Workbench.
(Edcelle John Gulfan)
6. 8-8-Python Bulk Insert MySql | Pandas Bulk Insert | Bulk Upload Dataframe To Mysql Table -Python2020

Top Articles

You might also like

Latest Posts

Article information

Author: Moshe Kshlerin

Last Updated: 11/22/2022

Views: 6283

Rating: 4.7 / 5 (57 voted)

Reviews: 80% of readers found this page helpful

Author information

Name: Moshe Kshlerin

Birthday: 1994-01-25

Address: Suite 609 315 Lupita Unions, Ronnieburgh, MI 62697

Phone: +2424755286529

Job: District Education Designer

Hobby: Yoga, Gunsmithing, Singing, 3D printing, Nordic skating, Soapmaking, Juggling

Introduction: My name is Moshe Kshlerin, I am a gleaming, attractive, outstanding, pleasant, delightful, outstanding, famous person who loves writing and wants to share my knowledge and understanding with you.