{'fraction_non_alphanumeric': 0.029790456955314314, 'fraction_numerical': 0.008864203764481472, 'mean_word_length': 4.841389480583319, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 2, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Storing, preprocessing and analyzing Tweets: Finding the suitable NoSQL system

NoSQL systems are a new generation of databases that aim to handle a large volume of data. However there is a large set of NoSQL systems, each has its own characteristics. Consequently choosing the suitable NoSQL system to handle Tweets is challenging. Based on these motivations, this work is carried out to find the suitable NoSQL system to store, preprocess and analyze Tweets. This paper presents the requirements of managing Tweets and provides a detailed comparison of five of the most popular NoSQL systems namely, Redis, Cassandra, MongoDB, Couchbase and Neo4j regarding to these requirements. The results of this work show that for Tweets storing, preprocessing and analyzing, MongoDB and Couchbase are the most suitable NoSQL systems. Unlike related works, this work compares five NoSQL systems from different types in a real scenario which is Tweet storing, preprocessing and analyzing. The chosen scenario enables to evaluate not only the performance of read and write operations, but also other requirements related to Tweets management such as scalability, analysis tools support and analysis languages support.


Introduction
As we live in the age of social media, a large volume of data is generated every day when we upload pictures on Instagram, post Tweets on Twitter, comment to a post on Facebook, or do any other activity on social networking sites. Social media data have the potential to bring smartness in many sectors, for instance, they can be used to identify management issues in food industry [61], they can also help in disaster management by propagating emergency informations [38], or be explored as a data source for public health monitoring [66]. In other words, social media data is driving big changes in different sectors and tourism is one of the most influenced sectors.
In tourism, social networking platforms play an important role in travel review and recommendation [47] [48]. Furthermore, they can be used as an alternative of traditional surveys in order to understand tourists' preferences [33] [63]. Twitter is a social media platform where tourists can share their travel experiences and express their impressions about tourism destinations, hotels or restaurants using Tweets which are short messages limited in 280 characters. Consequently, Twitter plays the role of online review [63] in tourism industry. Furthermore context-aware recommendation systems can use Tweets to determine preferences of tourists in real time [46], this can help to recommend the suitable destination, hotel or activity.
Tweets often contain significant informations because they are concise and, in most cases, posted in real time, which explains the use of Tweets to perform analysis in tourism [59]. However, the incredible amount of data captured by Twitter needs to be stored for further processing. Storing Tweets can be challenging for many database systems, because, on the one side, we have to deal with a large volume of semi-structured data, and on the other side, we have to prepare data for the analysis phase. In this context, relational database systems that are originally created to store structured data, have many limitations in handling Tweets.
NoSQL databases are a new generation of database systems defined in order to handle large datasets. They become a choice of many organizations that are dealing with massive data [29]. However we can find a large set of NoSQL systems, every one has its own approach to store and to query data. Consequently choosing the suitable NoSQL system to handle Tweets can be a challenging task.
In this context, our work is carried out to find the suitable NoSQL system to store, preprocess and analyze Tweets. This paper provides a detailed comparison of five of the most popular NoSQL systems namely, Redis 1 , Cassandra 2 , MongoDB 3 , Couchbase 4 and Neo4j 5 regarding to Tweets management requirements. To do that, we need to answer the following questions : 1. What are the requirements of managing Tweets ? 2. How does every NoSQL system respond to Tweets management requirements ?
This paper is divided into seven sections. Section 2 gives a definition of NoSQL databases, as well as an overview of the five chosen NoSQL systems, namely, Redis, Cassandra, MongoDB, Couchbase and Neo4j. In section 3 we present the most important requirements of managing Tweets and we describe how the five NoSQL systems respond to these requirements. A case study is presented in section 4 which aims to evaluate the performances of the five NoSQL systems. Section 5 discusses the comparison results. And section 6 provides some related works. Finally, our conclusion is given on the last section.

NoSQL Databases
In this section, we give a definition of NoSQL databases, as well as the characteristics of the five chosen NoSQL systems, which are Redis, Cassandra, MongoDB, Couchbase and Neo4j.
Relational database systems have been widely used since 1970. They are based upon the ACID (Atomicity, Consistency, Isolation, Durability) model, and they use SQL (Structured Query Language) to query data, therefore they provide good performance in handling structured data. However Relational database systems have some drawbacks in dealing with semi-structured (XML (Extensible Markup Language), JSON (JavaScript Object Notation),..) and unstructured data (documents, videos, emails,..) which represent a big part of today's data [41]. Relational database systems have also some limits in handling huge volume of data, which requires high scalability and availability.
NoSQL database systems have been defined with the purpose to provide high scalability and availability. The NoSQL movement is started in 2007 when Amazon published a paper about Dynamo, their key-value database system. Dynamo was created to provide high availability of Amazon's services by scarifying consistency in some cases [24]. NoSQL term (Not Only SQL) is often used to describe distributed, non-relational and scalable database systems [10]. NoSQL database systems are designed to handle large volume of data, therefore data are distributed across servers called nodes and they are replicated in order to insure high availability. Data replication can follow two strategies. The first strategy is the master-slave replication which consists of one master node that receives write operations, and many slave nodes that replicate the master node. The second strategy is the master-master replication where nodes play the same role.
NoSQL databases are classified in four different categories: key-value, column-oriented, documentoriented and graph-oriented [10]. There are many NoSQL database systems, each one has its own characteristics. In this work we choose five NoSQL systems, from the four categories, namely Redis, Cassandra, MongoDB, Couchbase and Neo4j based on their popularity and their large use. 1 redis.io 2 cassandra.apache.org 3 www.mongodb.com 4 www.couchbase.com 5 neo4j.com Redis is a key-value database system, created by Salvatore Sanfilippo in 2009 [55]. Redis is in-memory database which means that data are loaded into memory, and they are saved periodically to the hard disk [31]. By being in-memory database, this NoSQL system provides important performances in read and write operations, however it is limited by the physical memory [31]. It has a master-slave replication model and it provides SET and GET commands to respectively insert and query data [8].
Cassandra is created by Facebook in 2008 to handle Inbox search [39]. It is a column-oriented database, which means that data are stored as rows and columns. Cassandra is no longer schema-less, which means that a table must be defined before inserting data [4]. It provides a ring architecture, and data are replicated with a master-less strategy, which means that all nodes play the same role [10]. This NoSQL system uses its own query language, which is a SQL-like language called CQL [1].
MongoDB is created by DoubleClick in 2007 [10]. It is a document-oriented database systems, which means that data are stored in documents. The format in which documents are stored is BSON which is a binary-encoded serialization of JSON. For this reason, MongoDB is a schema-less database system, this means that it is not necessary to define the database schema at the beginning. Data are replicated with a master-slave model [5]. MongoDB provides many methods to insert, query, update and delete documents.
Couchbase is created by Memcached in 2011 [10]. It is a document-oriented and key-value database. Each record consists of a key and a value. A value can be either binary or JSON. Binary value can only be retrieved by key, however JSON value can be parsed, indexed, and queried [3]. In Couchbase, data are replicated with a master-master model. N1QL is the query language provided by Couchbase to query documents, it has a SQL-like syntax and semantic [3].
Neo4j is a graph-oriented database, created by Neo Technology, Inc in 2007 to handle highly connected data [10]. Since it is a graph-oriented database, Neo4j stores data using nodes and relations. In Neo4j, data are not distributed because nodes are highly interconnected. However, the all graph can be replicated with a master-slave replication model. Neo4j provides Gremlin and Cypher as query languages in order to create and query graphs [49]. As we present in the current section, we choose to use different types of NoSQL systems in order to evaluate and compare all categories. However, we need first to define the requirements on which we based our comparison. In the following section, we give the most important requirements of managing Tweets and we present how every NoSQL system responds to these requirements.

Tweets management Requirements
The goal of our work is to find the most suitable NoSQL database system to store, preprocess and analyze Tweets. However, we need first to define the Tweets management requirements. For this end, we discuss in this section two requirements of storing and managing Tweets, which are scalability in addition to analysis tools and languages support, however we discuss the third requirement, namely the performance, in a detailed case study in section 4.

Scalability
Several applications use a huge volume of Tweets. Thus, database systems have to deal with growing data. In the context of databases, the term scalability can be defined as the capability of a database system to handle growing data. In other words, we consider a database highly scalable, when it is able to add new data without loosing its performances. This includes the capability to redistribute data when adding new node while keeping data available. There are two approaches to scale a database: • Vertical scalability: called also scale-up [55], consists of adding new resources to the node, such as adding RAM (Random Access Memory), making disk input and output go faster, or by moving data to a new expensive big server, which can decrease system's performances [55]. Centralized databases scale vertically.
• Horizontal scalability: called also scale-out [55], consists of adding new nodes. Distributed databases, namely NoSQL databases, are designed for horizontal scalability, because they distribute data across many small machines. This makes the scalability much more easier and less expensive [16].
To sum up, in order to handle Tweets, the database system has to be highly scalable. Since we are interested by NoSQL databases, we compare the five NoSQL systems regarding to horizontal scalability.

NoSQL systems and Horizontal Scalability
The scalability is one of the major factors that make NoSQL databases popular. However the scalability performance changes from a database system to another. One of the reasons that make the scalability performance higher is the database architecture. According to [64], the Master-Master architecture systems are highly scalable, because nodes are identical, which makes the scalability less complicated. This means, as we presented in our previous work [10], that Cassandra and Couchbase have high performance in scalability. The scalability is also influenced by the data model of the database. In [19], the authors considered that graph databases, such as Neo4j, provide low scalability performance compared to other data model types. This can be explained by the fact that a graph can not be distributed across nodes, which makes the scalability more complicated. Another scalability factor is data auto-sharding. Auto-sharding is the capacity of a database system to distribute data across nodes automatically. In Redis, data have to be distributed by the user [22], which makes Redis scalability poor [31]. However, Cassandra [37], Couchbase [70] and MongoDB [30] provide automatic data distribution across nodes. To sum up, Couchbase and Cassandra provide better performance in scalability compared to the other systems, MongoDB provides important performance too, however Neo4j and Redis have some limits in scalability.

Analysis tools and languages support
The main goal of gathering Tweets is to analyze them. For this reason, database systems have to support analysis tools connectivity and to provide modules and libraries for analysis languages.
There is a lot of analysis tools such as Hadoop [65], Apache Spark [60], and Apache storm [35]: • Hadoop is a software framework that provides large scale distributed data analysis [65].
Hadoop provides HDFS (Hadoop Distributed File System ), which is a master-slave architecture that stores data and executes read and write instructions. Nevertheless, in some applications, we need to use other database systems instead of, or with, HDFS.
• Apache Spark is a unified engine for distributed data processing [69] which makes data analysis faster [60]. It provides API (Application Programing Interfaces) in many programming languages and also supports many tools including structured data processing (Spark SQL), machine learning (MLlib), graph processing (GraphX), and Spark Streaming [9].
• Apache Storm is a stream processing system that can process unbounded streams of data very fast [35]. Storm applications are called topologies. A Storm topology is a graph of tasks that process distributed streams of data. As long as it is not stopped by the user, a topology can run forever [52].
The most used analysis languages are R language [7] and Python language [57]: • R is an analysis language for statistical computing and graphics, it is similar to the S language [18]. R provides statistical and graphical techniques and it allows users to add more functionality by defining new functions [7].
• Python is one of the most used languages for analysis thanks to its object oriented design and modularity [57], it is both simple and powerful. This makes it easier to work with Python in many contexts.

NoSQL systems & Analysis tools and languages
The ability to connect to analysis tools and languages makes the database system more suitable to store, manage and analyze Tweets. For this reason we discuss in the following the drivers, connectors and libraries provided to ensure this integration.
• Redis can be used with Hadoop as Cache Server [58], which can improve the performance of MapReduce job, since accessing data from Cache is faster than disk, it is used in several works [45] [58]. Redis provides also the spark-redis package, which is the Redis connector for Apache Spark [8]. Spark Redis integration is used in many works such as [12] where authors use Redis and Spark to collect and analyze real time data. Storm adopter can use Storm-redis to either retrieves or store values into Redis [2]. For instance, Redis and Storm are used in [62] to create a framework of data processing applications. Moreover, Redis can be used with R language using Rredis package [7] and it can be used with Python using redis-py module [42].
• Cassandra can be used with Hadoop as the input or output of map reduce jobs by doing some setups and configurations [15]. [26] and [68] are examples of works that use Cassandra and Hadoop integration . To connect Spark to Cassandra, we need to add Cassandra connector to the Spark project [21], this integration can be used to benefit from the consistency storage of Cassandra and the fast processing of Spark [43]. In other hand, Storm-cassandra is a library that enable to work with Storm on top of Cassandra [2], this integration is used in [34] to define a data processing platform for intelligent agriculture. Finally, to connect Cassandra with R language, we can use Rcassandra which is a package provided by R-project [7], however, Python programmers can use Cassandra-Driver module to work with Cassandra [7].
• MongoDB and Hadoop integration has been used in many applications for scientific data analysis [25], Time-dependent shortest path calculation [13], and other application fields [23]. However, this integration is no longer supported by MongoDB [5]. MongoDB provides a connector for Spark to use all Spark libraries [5]. MongoDB and Spark are used in [40] to analyze data collected from smart clothes, this integration is also used in [51] to define an architecture for traffic monitoring. Storm provides a package that enables to work with MongoDB, it enables to both insert and update data [2]. Storm and MongoDB are used in a real-time framework to analyze self-health data collected from wearable devices [14]. Finally, RmongoDB is a MongoDB client for R, which is used in [32] to analyze comment on e-commerce websites, and Pymongo is a module for Python which is used in variety of works, among them Tweets analysis [50]. • Neo4j and Hadoop integration is used in many works, among them web crawling [56] and power network topology processing [44]. This is the suitable choice when working with networked data. Neo4j also provides Neo4j-Spark-Connector that enables to transfer data from and to a Neo4j database [6]. Neo4j and Spark are used in [27] to evaluate the similarity between objects. Similarly to Couchbase, there is no integration of Neo4j and Storm. However, Neo4r is a Neo4j driver that allows to use Neo4j with R [7], and Neo4j-driver is a Python module that can be used with Python. Time-varying Social Networks [17] and emotion analysis [28] are examples of works that implements Python with Neo4j.  In this section we discussed two Tweets management requirements, which are scalability in addition to analysis tools and languages support. In order to evaluate the performance of the five NoSQL systems in details, we present in the following section a case study of collecting, storing, preprocessing and analyzing Tweets.

NoSQL systems and Performance: A case study
Analysis applications need to provide good performance in term of execution time. One of the factors that influence the application performance is the database read and write performances. NoSQL database systems provide, relatively, high performance of read and write operations, but, there is a difference from a database system to another.

Presentation of the case study
In order to compare the five NoSQL systems' performances, we conduct an experiment where we use them in storing, preprocessing and analyzing Tweets. This experiment aims to evaluate write and read performances of the five NoSQL systems through a case study that aims to analyze Tweets about tourism in Morocco. To this end, we first collect Tweets containing the most visited cities in Morocco, then we insert the collected Tweets in the five NoSQL systems which enables to evaluate write performance of each system. After that, a preprocessing phase is needed to prepare data to be finally analyzed. Tweets preprocessing and analyzing enable to evaluate read and write performances of the used systems.
In this case study, Tweets are processed using a Python programming interface. This choice is based on the language simplicity and the ability of use with the five NoSQL systems. Moreover, the interfaces used in Tweets insertion, preprocessing and analyzing are the same for the five NoSQL systems. As a consequence, the database system is what makes the difference.
All experiments are executed in one machine with the following configuration: • CPU: Intel(R) Core(TM) i7-7700 CPU @ 3.60 GHZ • RAM: 16 GB

Tweets collection
Twitter provides an API to harvest Tweets on a specific topic. By using a programming language and Twitter API, we can collect a large volume of Tweets to match with a specific topic. Tweets are mainly generated in JSON format, however, we can use any other format such as CSV (Comma Separated Values).
In this work, we are interested by the tourism of Morocco. Hence, we aim to collect Tweets containing Moroccan cities. To this purpose, we defined a Python programming interface to collect Tweets using a list of Moroccan cities (Marakech, Agadir, Casablanca, Chefchaouen...). As a response, a JSON file is generated containing more than 1000000 Tweets 6 . Additionally to the text, each Tweet contains several properties such as Tweet ID, creation date, user ID, user name, and user description. Listing 1 is an example of the collected Tweets.

Write performances for Tweets insertion
In this experiment, we need to insert data from a JSON file in the five databases. Tweets insertion enables to compare the write performances of the five NoSQL systems. However, not all these NoSQL systems provide tools that enable to load a JSON file to the database. MongoDB provides mongoimport tool which imports data from Extended JSON, CSV, or TSV (Tabulation-Separated Values) files. It also provides an exporting tool called mongoexport that exports mongodb documents to a JSON, CSV or TSV files. These two tools are very useful in data management. Couchbase provides cbdocloader command to load data from JSON file, however it loads a group of JSON documents in a given directory or in a single zip file into a Couchbase bucket, which means that every JSON file has to contain only one document which is not the case with our data. Which means that we need to transform the JSON file before using cbdocloader. Cassandra, Neo4j and Redis do not provide any tool to import data from a JSON file. For this reason we use, for every database system, an interface that loads data from JSON file and inserts them into the database.
As we mentioned previously, the JSON file generated by Twitter API contains a lot of informations about the Tweet and the user who posted it. Furthermore, the number of informations can change from a Tweet to another. For instance, if the Tweet is retweeted, which means that is forwarded, we will find 34 additional informations about the retweet and the user who reposted it. Thus, a unified schema is needed, not only because there is a plenty of informations that we do not need in the analysis, but also because not all the five NoSQL systems can handle a dynamic schema dataset. Consequently, in order to have the same schema for all systems, we keep only the following fields: Tweet identifier (id str) , date of Tweet (created at), Tweet message (text), user identifier (user.id str), user name (user.name), user description (user.description), user location (user.location).
As a result, the database models are as follow:  • In Cassandra we stored the data in a table called Tweets containing eight columns, as follow: Tweets( tweet id, created at, tweet text, tweet source, user id, user name , user location , user description ). Where tweet id is the primary key.
• In MongoDB we store data in a collection called Tweets which contains data records in Binary JSON format, as shown in Fig 2 . •   To insert Tweets into the five NoSQL systems, we have written a python script that extracts Tweet by Tweet from the JSON file and insert the selected fields into the database as shown in the algorithm 1.
For every NoSQL system, we use a method defined by the Python Driver in order to insert data into the database. For Redis, we use the HSET command which enables to store every Tweet in a hash with a unique key which is the Tweet id (id str). The other Tweets informations (text, source..) are added to the hash as key-value pairs. For Cassandra, we use the execute method that, as its name implies, executes CQL commands such as INSERT INTO used in our case. With MongoDB, we use the method insert one that enables to insert a JSON document into the database. Similarly to MongoDB, we use the insert method in order to insert a JSON document into Couchbase. For Neo4j, we use the run method that aims to execute a Cypher command which creates the graph and inserts data into it.
We execute the code using different numbers of Tweets in order to compare the five databases relatively to different sizes of data.  The results of Tweets insertion reveal that Couchbase takes the lowest time for Tweets insertion. The time that Tweets insertion takes for Couchbase is approximately half the time that it takes for Redis, Cassandra and MongoDB. However, Neo4j is significantly slower than the other systems.
MongoDB and Couchbase are the only database systems, from the chosen systems, that use JSON as data model, and both of them have commands that help to load data from JSON files automatically. For this reasons, we compare the write performances of MongoDB and Couchbase using respectively mongoimport and cbdocloader tools. furthermore, in this experiment, we use all fields of Tweets. Table 6, shows that MongoDB has better write performance when using mongoimport tool. Moreover, to insert Tweets using cbdocloader tool, we need to divide the single file that contains 1000000 Tweets into 1000000 files, each contain one document.  Table 6: MongoDB and Couchbase insertion time (in seconds) using mongoimport and cbdocloader tools After inserting Tweets in the five NoSQL systems and compare the time that it takes for every system, we present in the following Tweets preprocessing that helps to clean the Tweets' text before being analyzed.

Read and write performances for Tweets preprocessing
Tweet preprocessing is an important step that prepares the Tweets for the further processing. In this step we remove spatial characters, uppercase, emojis in order to make the text readable by the analysis algorithm. In our case study, we create a python code that reads the text from the database, cleans the text using tweet-preprocessor Python module, and stores the new text in a new field called cleanedText as described in the algorithm 2. Consequently, Tweets preprocessing enables to compare read and write performances of the five NoSQL systems. Both in Tweets prepocessing and analyzing, we have used datasets of 1000000 Tweets.
For Schema-less databases namely MongoDB, Couchbase and Redis, we create the new field (cleanedText) during the preprocessing phase. However, for Cassandra and Neo4j we have to create this field when we define the database model, we modify then its value by inserting the new text. Different queries are used to read Tweets' text from the five databases and to insert the cleaned texts into the databases. For Redis, we first use the command keys that read all the keys of the database. Then we use these keys in the command hget in order to read the value associated with the field text, and we use the command hset to insert the cleaned text into the database. For Cassandra, we use the CQL command SELECT .. FROM to select Tweets' text and we use the command UPDATE.. SET .. to insert the cleaned text into the database. Regarding MongoDB, we use the method find() that selects documents from the collection and we use the method update() to modify the document by inserting the cleaned text. In Couchbase, we use the N1QL query SELECT .. FROM to select Tweets' text, and we use the method mutate in that enables to modify documents in order to insert the cleaned text. For Neo4j, we use the Cypher command MATCH .. RETURN to select Tweets' text and we use the command SET to insert the cleaned Text.

Read performances for Tweets analysis
In order to compare read performances of the five NoSQL systems, we have analyzed the collected Tweets using a sentiment analysis. Sentiment analysis enables to identify the polarity of a text, by classifying it into positive, negative and neutral. The interface we create for sentiment analysis enables to read Tweets text from the database and apply sentiment analysis as shown in the algorithm 3. We have implemented the sentiment analysis using NLTK (Natural Language Toolkit), which returns for each Tweet the probabilities of it being negative, neutral and positive. The tool uses two classifiers, a Naive Bayes Classifier and a Hierarchical Classifier [54].

Discussion
The goal of the current work is to find the appropriate NoSQL system regarding to Tweets management requirements, which are scalability, analysis tools support, analysis languages support, and performance. After comparing the five chosen NoSQL systems in the previous sections, we summarize in the following the comparison results for each system: Redis has important performances in all test especially Tweets preprocessing. This can be explained by the fact that Redis loads all data in memory, which can be at the same time a drawback, because it limits the volume of data that can be stored in Redis. As presented in subsection 3.1, Redis has also some limits regarding to scalability. However, in term of analysis tools and languages support, Redis can operate with all tools and languages previously presented.
Cassandra is quite efficient with Tweets analyzing which means that it has important performances in data reading as Tweets analyzing is based on data reading. Cassandra has also significant performances in scalability and it can work with all analysis languages and tools reported in this paper. The only limit of Cassandra is that we need to define the database schema before inserting data which can cause some drawbacks in handling semi-structured data.
MongoDB has also significant performances in Tweets insertion by using the mongoimport command, and Tweet analyzing as well. Another advantage of MongoDB is being a documentoriented system which enables to handle Tweets more efficiently. In term of scalability, MongoDB has important performances, and it can integrate the most of analysis tools and languages except Hadoop which is no longer supported by MongoDB.
Couchbase is another document-oriented system, which means that is quite efficient in storing JSON data such as Tweets. it has also important performances in Tweets insertion as well as scalability. Couchbase provides cbdocloader tool in order to import data from JSON files automatically, however we need to prepare a JSON file before using the tool. Moreover Couchbase can not integrate all analysis tools and languages namely Storm and R language.
Neo4j has the lowest performances in all tests, especially in Tweets insertion and preprocessing where the difference between Neo4j and the other systems is huge. Neo4j has also some drawbacks in scalability. However it can work with all analysis tools and languages that we presented in this work, except Storm.
Based on these results, we can conclude that MongoDB and Couchbase are the most suitable in storing, preprocessing, and analyzing Tweets.

Related Works
There is considerable existing works that compare NoSQL systems. In this section, we present some related works that compare NoSQL systems characteristics.
In [20], authors compare between Mysql 7 as a SQL database system and MongoDB as a NoSQL database system in term of performance. In this comparison, Tweets are used as a dataset to compare the performance of input, retrieve and delete operations of each database. The results of this comparison show that MongoDB performance is better than MySQL in all operations. This research compares performances of SQL and NoSQL databases in storing Tweets, however, it has tended to focus on one NoSQL system.
Another comparative analysis of NoSQL database systems is provided in [67]. In this work, six NoSQL database systems namely, AeroSpike 8 , BerkeleyDB 9 , CouchBase, HBase 10 , MongoDB and Redis, are compared regarding to metrics such as performance, Memory consumption, ease of use, nature of data and integration of processing platforms. The authors use a dataset of unstructured medical data, containing medical tests, credit card data, office documents (word, excel), video and audio streams. The results of this comparison show that MongoDB has the highest use of memory (89%), while Redis has the lowest use of memory (18%). For loading data from the database to RAM, AeroSpike has the best performance among all database systems, however Berkeley has the best performance in data querying. This comparison seems to be useful because a large dataset is used. However they do not use all NoSQL systems categories. Another difference between this comparison and our work is data type.
In [53], Pereira and colleagues compare three document-oriented NoSQL systems: Couchbase, MongoDB and RethinkDB 11 . In their performance evaluation experiments, authors compare write, read, update and delete performances of the three chosen systems. These operations are evaluated in two scenarios. One thread scenario, where one request is sent to the database in order to evaluate the response time of the three systems. However, the multiple threads scenario aims to verify how Couchbase, MongoDB and RethinkDB work with multiple requests in the same time. The results of this comparison show that Couchbase has a better performance at the majority of the operations, however, MongoDB scores better just in writing and reading documents with multiple threads. The goal of this comparison is to evaluate how these NoSQL systems works in real time, but it focuses on document-oriented systems while there are other types of NoSQL systems that seem to have important performances in real time.  In the literature, there are many works that compare NoSQL systems from different points of view. However there is no work that compare NoSQL database systems regarding to Tweets management requirements. In this paper, we compare five NoSQL systems from different types in a real scenario which is Tweet storing, preprocessing and analyzing. The chosen scenario enables to evaluate not only the performance of read and write operations, but also other requirements related to Tweets management such as scalability, analysis tools support and analysis languages support.

Conclusion and Futur Works
In this paper, we provided a detailed comparison of five NoSQL systems namely, Redis, Cassandra, MongoDB, Couchbase and Neo4j regarding to Tweets management requirements which are scalability, analysis tools support, analysis languages support, and performance. We presented a detailed discussion of the five NoSQL systems' scalability performances and we reported the analysis tools and languages supported by these systems. Moreover we conducted an experiment where we use the five NoSQL systems in storing, preprocessing and analyzing Tweets. This experiment aims to evaluate write and read performances of the five NoSQL systems through a case study that aimed to analyze Tweets about tourism in Morocco. The results of this work shows that MongoDB and Couchbase are the most suitable NoSQL systems to store preprocess and analyze Tweets.
Our future works will concentrate on how to unify the access to data stored in MongoDB and Couchbase in order to be able to use both of them within a single application more easily and efficiently.