Golang and Scylla Part 2 – Data Types

12 min to complete

In a previous lesson, Golang and Scylla Part 1, we explained how to use the Golang driver to create applications that interact with Scylla. Division 3 has decided to explore the Golang programming language a bit further and came across an exciting feature of Scylla that would allow us to store files in the database. With this ability, we can store images of the mutants in the catalog keyspace. With the images stored, Division 3 can see what the mutant looks like whenever they want and even share the image and tracking details with local law enforcement officials if needed.

A table in Scylla supports a wide array of data types such as timestamp, text, integer, UUID, blob, and more. The blob datatype stores binary data into a table. For Division 3’s use case, we will add a blob column to the catalog.mutant_data table and store images for each mutant there using a Golang application. Since Scylla is a distributed system with fault protection and resiliency, storing files in Scylla will have the same benefits as our existing data based on the replication factor of the keyspace. To get started, we will first need to set up the Scylla cluster.

Starting the Scylla Cluster

follow this procedure to remove previous clusters and set up a new cluster.

Next, create the keyspace catalog and the table mutant_data

docker exec -it mms_scylla-node1_1 cqlsh
CREATE KEYSPACE catalog WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy','DC1' : 3};
use catalog;
CREATE TABLE mutant_data (
   first_name text,
   last_name text,
   address text,
   picture_location text,
   PRIMARY KEY((first_name, last_name)));

Now let’s add a few mutants to the catalog with the following statements:

insert into mutant_data ("first_name","last_name","address","picture_location") VALUES ('Bob','Loblaw','1313 Mockingbird Lane', 'http://www.facebook.com/bobloblaw');
insert into mutant_data ("first_name","last_name","address","picture_location") VALUES ('Bob','Zemuda','1202 Coffman Lane', 'http://www.facebook.com/bzemuda');
insert into mutant_data ("first_name","last_name","address","picture_location") VALUES ('Jim','Jeffries','1211 Hollywood Lane', 'http://www.facebook.com/jeffries');

The Golang sample application that we are using was modified from the Datastax Blob example located on the Cassandra Driver’s GitHub page.

Building the Golang Example

If you previously built the Golang  Docker, you can skip directly to “Running the Golang Example.”

Otherwise, to build the application in Docker, change into the “mms/go” subdirectory in scylla-code-samples:

exit
cd scylla-code-samples/mms/go

Now we can build and run the container:

docker build -t go-app .

To run the container and connect to the shell, run the following command:

docker run -d --net=mms_web --name some-go-app go-app

To connect to the shell of the container, run the following command:

docker exec -it some-go-app sh

Running the Golang Example

Finally, the sample Golang application can be run:

godatatypes

The output of the application will be:

Let’s dive a little bit deeper to see what the code is doing. When the application is run, it will add two columns to the catalog.mutant_data table: b and m. Column b is the blob column where the binary file is stored, and column m is used to record the file’s name.

In the container, there is an image file for each mutant that will be read by the Golang application and stored in Scylla according to their names.

This code reads the file and inserts it into Scylla:

The following function will read the file from Scylla, convert it to ASCII, and save it as a file in /tmp.

Finally, it all comes together in the main function, which for each mutant: reads the file, inserts it into Scylla, reads the file from Scylla, and saves it.

To retrieve the images from the container to verify that everything worked correctly, we can run the following Docker commands to copy the newly written images out of the container and to your machine:

exit
docker cp some-go-app:/tmp/Jim_Jefferies.jpg .
docker cp some-go-app:/tmp/Bob_Loblaw.jpg .
docker cp some-go-app:/tmp/Bob_Zemuda.jpg .

Using your favorite image viewer, you can verify that each image is correct.

Conclusion

In this lesson, we went over the different data types that someone can use in their database tables and learned how to store binary files in Scylla with a simple Golang application. By being able to store images in Scylla, Division 3 will be able to quickly see what a mutant looks like and can share the details with local law enforcement if needed. With the ability to store files in the Mutant Monitoring System, the possibilities are endless for how Division 3 can continue to evolve the system. Please be safe out there and continue to monitor the mutants!

 

fa-angle-up