Julia Cookbook: Over 40 recipes to get you up and running with programming using Julia

Assign a variable to the local source directory of the file:

s = "/Users/username/dir/iris.csv"

The readtable() command is used to read the data from the source. The data is read in the form of a Julia DataFrame:

iris = readtable(s)

Create a data structure with some data inside it. For example, let's create a two-dimensional dataframe to view the the process of writing files of different formats better using DataFrames:

df = DataFrame(A = 1:10, B = 11:20)

Now, the dataframe created in Step 1 can be exported to an external CSV file by using the following command:

writetable("data.csv", df)

Assign a variable to the local source directory of the file:

s = "/Users/username/dir/data.tsv"

The readtable() command is used to read the data from the source. The data is read in the form of a Julia DataFrame:

data = readtable(s)

Create a data structure with some data inside it. For example, let's create a two-dimensional dataframe like the one we created in the previous example:

using DataFrames
df = DataFrame(A = 1:10, B = 11:20)

Now, the dataframe, which we created in Step 1, can be exported to an external TSV file using the following command:

writetable("data.csv",df)

Install the DBI package. The DBI package is a database-independent API that complies with almost all database drivers.

The DBI package from Julia can be installed by directly cloning it from its repository using the following statement:

Pkg.clone("https://github.com/JuliaDB/DBI.jl")

Then, install the PostgreSQL library by directly cloning the library's repository using the following statement:

Pkg.clone("https://github.com/JuliaDB/PostgreSQL.jl")

SQLite is a light, server-less, self-contained, transactional SQL database engine. To interact with data in SQLite databases, one has to first install the SQLite server and make sure that it is up and running and displaying a prompt like this:

Now, the SQLite bindings for Julia can be installed through the following steps:

Firstly, import the requisite packages, which are the DBI and the PostgreSQL databases, using the import statements:

using DBI
using PostgreSQL

In addition, the required packages for the PostgreSQL library are as follows:

Make a connection to a PostgreSQL database of your choice. It is done through the connect function, which takes in the type of database, the username, the password, the port number, and the database name as input parameters. So, the connection can be established using the following statement:

conn = connect(Postgres, "localhost", "password", "testdb", 5432)

If the connection is successful, a message similar to this appears on the screen:

PostgreSQL.PostgresDatabaseHandle(Ptr{Void}

        @0x00007  fa8a559f160,0x00000000,false)

Now, prepare the query and tag it to the connection we prepared in the previous step. This can be done using the prepare function, which takes the connection and the query as parameters. So, the execution statement looks something like this:

query = prepare(conn,  "SELECT 1::int, 2.0::double precision, 
        'name'::character varying, " *  "'name'::character(20);"))

As the query is prepared, let's now execute it, just like we did for MySQL. To do this, we have to enter the query variable, which we created in the previous step, into the execute function. It is done as follows:

result = execute(query)

Now that the query execution is over, the connection can be disconnected using the finish and disconnect functions, which take the query and the connection variables as the input parameters, respectively. The statements can be executed as follows:

finish(query)
disconnect(conn)

Now, the results of the query are in the result variable, which can be used for analytics by either moulding it into a dataframe or any other data structure of your choice. The same method can be used for all operations on PostgreSQL databases, which include addition, updating, and deleting.

This resource would help you better understand the Database-Independent API (DBI), which we use to connect local PostgreSQL databases such as SQLite.

Import the SQLite package into the current session and ensure that the SQLite server is up and running. The package can be imported by running the following command:

using SQLite

Now, a connection to any database can be made through the SQLiteDB() function in Julia Version 3 and the SQLite.DB() function in Julia Version 4.

The connection can be made in Julia version 4 as follows:

db = SQLite.DB("dbname.sqlite")

The connection can be made in Julia version 3 as follows:

db = SQLiteDB("dbname.sqlite")

Now, as the connection is made, queries can be executed using the query() function in Version 3 and the SQLite.query() function in Version 4.

Start by importing the package:

Pkg.add("Requests")

Next, import the necessary modules from the package for quick use. The modules that will be used in this recipe are get, post, put, and delete. So, this is how to import the modules:

import Requests: get, post