The application of e-commerce has gradually become a norm for people to meet the demands of obtaining both their necessities and desires. It bloomed during the COVID-19 pandemic when consumers had restricted mobility to purchase goods, offering optimal convenience through internet-enabled devices. As time progresses, it has opened more opportunities for business owners to expand their market reach internationally, allowing consumers a variety of products to purchase from. However, the trend of online shopping is foreseen to grow even bigger due to its active digitalisation on the economy (Akhmetovaet al., 2022). The dynamic changes in consumer behaviours also demands for advancements in technologies and the emergence of new business models (Klemová, 2024). This calls for an increasing need for robust and scalable database management systems to manage these vast amounts of data and digital transactions happening within the retail and e-commerce industries.

With the emergence of big data and the concept of the 5 V’s (Volume, Variety, Velocity, Veracity, and Value), big data analysis in retail and e-commerce businesses has become a crucial area of study. According to research by Niranjan et al., (2016), a data-driven approach, also known as Data-Driven Decision-making (DDD), is increasingly important for retail and e-commerce businesses. Given the massive amounts of data generated by online transactions (retails purchases via e-commerce and m-commerce), DDD enables companies to make informed decisions that can significantly impact their operations and success in the industry.

Utilising DDD, retail companies and those engaged in e-commerce can make more informed decisions by providing insights into customer behaviour, preferences, and trends (Niranjanet al., 2016). This enhances customer experience, increases personalization and targeted marketing, as well as optimizes operations for inventory management. Additionally, research by Kameswari et al., (2024) supports this by emphasising the role of data in the retail industry, encompassing data sourcing, data analysis, data storage, data security and privacy, as well as real-time data processing, and highlighting how such business utilize data to boost their income (increased sales).

Data can be leveraged as a competitive advantage, allowing businesses to predict trends and forecast demands, and according to Trachim, (2024), e-commerce companies compile huge datasets, including evaluating data from previous years. These datasets can be broken down to transactional data, such as sales and transaction records, and non-transactional data, such as customer data (customer information, behaviour, references, product data (product catalogues), inventory data (inventory management), and order data (order fulfilment, logistics, supply chain management) (Trachim, 2024).

Given the large amount of data, handlings such large volumes of diverse data can make data management for retail and e-commerce companies challenging. These challenges, as indicated by Smith, (2024), may include data silos, data synchronization, data quality and governance issues, and data security and privacy issues. It is crucial as it determines the businesses’ capability to leverage these vast amounts of data for empowering strategic decision making (Jaleel and Abbas, 2020). It is important for these companies to ensure fast, reliable, and secure data access, especially in adapting to the dynamic nature of e-commerce trends and customer behaviours.

Not only that, but data security is also a rising concern e-commerce business. Malicious attacks are constantly occurring on e-commerce platforms with intentions of stealing private customer information (Jamraet al., 2020). This demands businesses to employ robust technologies that can safeguard customer data and comply with privacy regulations (Smith, 2024). Hence, this highlights the significance of data in retail and e-commerce, thereby reinforcing our research objectives on the importance of selecting the right database model for these industries.

The aim of this research is to discover the suitability of the five database models (Relational, Graph, Wide Column, Key-value, Document) in application to the retail and e-commerce industry. Particularly, the literature seeks to understand the performance and the strengths and weaknesses of each database model in handling various aspects of retail and e-commerce functionalities, such as customer relationship management, order processing, product development, and inventory management. With this purpose in mind, the study poses the following research questions:

How do different database models impact data creation, manipulation, retrieval, access control and integrity?

Which database model provides the best performance for high volume transactions and operations in retail and e-commerce?

As a result, findings of these research questions with demonstrations of scenarios applied will enable retailers and e-commerce business owners to gain insights into choosing the best database model to optimize their business operations and boost customer satisfaction.

Data creation refers to the process of creating and defining data structures in a database. This process starts with the design of the database schema, which is the blueprint for the database. Schemas define the types of databases objects, also known as tables and entities, the relationship among these objects such as foreign key referencing and relationship multiplicity, and the constraints imposed on the tables such as integrity constraints (Liu and Özsu, 2018). Depending on the type of database model, the definition of each schema will differ slightly as the nature of NoSQL schemas are typically more flexible (Nayaket al., 2024). Following the completion of the schema, data entries will be inserted into each table. By defining the schema before populating the table, data integrity is maintained.

Data manipulation is the update, insert, or delete actions carried out when handling data. These processes are formally referred to as the Create, Read, Update, and Delete (CRUD) operations in database management (Gudivadaet al., 2018). Carrying out data manipulation can help ensure the accuracy of data. Different database models will use different data manipulation methods to modify the table contents. Consistently maintaining a database through data manipulation will product records that are reliable and efficient for daily operations.

Data retrieval is said to play a major role in achieving high performance and efficiency. It incorporates using a number of commands to request data to get the information from the database. Several database models enable different query languages and techniques to be used in a system. For example, relational databases are written in SQL, while some NoSQL databases, such as wide-column stores, use their own language, Cassandra Query Language (CQL). Some of the NoSQL databases do not follow a schema, allowing users to query and get rows and particular columns or a sequence of columns. As the size of the databases grow, indexes enable efficient queries resulting in fast data access (Yusof, 2017). Efficient data acquisition and retrievals guarantees that the required data is made available for use by the applications and users at required times.

Access control enables only those personnel who are permitted to access or modify data to do so, thus, protecting data from the outsiders. This is done through mechanisms like Role-Based Access Control (RBAC), Discretionary Access Control (DAC) and Mandatory Access Control (MAC). Users are defined in RBAC based on the role model where each role relates to privileges that are the actions the users can carry out in the database (Leet al.,2023). Another is the Data Access Control (DAC) enables data owners to set their access control policies for their data and the Mandatory Access Control (MAC) ensure that access policies of data are in compliance with the security labels assigned to the data and users. Strong access control measures need to be put in place to minimize the risks associated with privacy and security of information and policy noncompliance.

Data integrity is essential as it ensures that the data remains accurate, consistent and reliable throughout its entire life cycle (Cai and Zhu, 2015). In other words, the data must remain credible and cannot be compromised or corrupted in any way Duggineni, (2023). conducted research to identify measures that can ensure data integrity and prevent unauthorized access. One of the methods is to verify input data to ensure the accuracy of the data before it enters the database. Additionally, any form of unauthorized data modification can be prevented through access controls found within a DBMS. It is important for an organization to implement these methods and ensure that their data is trustworthy and secure.

A data model is a simplified diagram or flow chart that shows the entities, attributes and the relationships of a software system (Gilliset al.,2024). Data models contain various useful information about the data stored, such as the definition, type and format of the data, to support the development of the information system (Palanisamyet al., 2020). Through the data modelling process, various data validation techniques have been performed to ensure that the data stored in the data model is consistent and accurate. This is especially useful as it provides a standardized view of the data to all stakeholders involved in the business process. Thus, data models can be used to facilitate communication between the business and IT professionals as it provides a common reference point for discussion and setting the business requirements.

Data models can be represented by three common types which are known as conceptual data model, logical data model and physical data model. Each one of these types represent different phases during the data modelling process.

A conceptual data model is a high-level model that provides an abstract view of the data. The purpose of a conceptual data model is for business stakeholders to understand the structures and relationships within the data. This model focuses on essential data that is important to the business and omits the finer details (Tupper, 2011). Conceptual data models typically use notations such as entities and relationships.

Logical data models provide a more technical and detailed view of the data. For example, an Entity-Relationship Diagram (ERD) would include the optionality and cardinality in a logical data model (Luisi, 2014). The goal of logical data models is to provide a visual representation of the structure and relationship of the data elements needed to fulfil the business requirements. Logical data models use notations such as entities, relationships, attributes, primary and foreign keys.

The physical data model is the most detailed model amongst the three data models. This is because the model shows how data is stored in a specific Database Management System (DBMS) (West, 2011). Unlike the conceptual or logical data model that use notations like entities and attributes, the physical data model includes the tables, columns and constraints (Hughes, 2016). This model focuses on designing data structures in a way that optimizes resources while maintaining an optimal database performance.

Table 1 shows a summarized table of the comparisons between data models to allow researchers to identify the optimal model for their specific needs.

In a logical database design, data models such as ERDs, define the entities, attributes and relationships involved. The data is organized in a logical manner such that the relationships are formed based on the business requirements. This stage prepares the data to be physically implemented in a DBMS. The physical implementation stage then translates the logical design into a real database structure, considering specific storage methods and optimization techniques to ensure efficient data handling and retrieval.

A Relational Database (RDBMS), also known as an SQL database, is a logically structured database that comprises of a collection of relations (Harrington, 2009). RDBMS are most commonly used today as each data entry is stored in tables with columns to define the nature of the data (Bourgeois, 2014). This improves the visualization of the database as users can immediately extract the data entities and entries they want. Relational databases are also known for using structured approaches to allow data creation, data manipulation, data retrieval, access control, and data integrity. SQL language is used to manage operations related to the characteristics mentioned below (Oracle Australia, 2024).

To create data, a schema must first be defined. Entities are known as tables. Tables are created using CREATE command after defining the columns that represents an attribute. The relationships that link a table to another are also defined through FOREIGN KEY referencing. Lastly, constraints are given to each table to maintain data integrity. For example, integrity constraints or PRIMARY KEY constraints are applied to each table to ensure that each entry is unique. After the completion of these tasks, data records will be entered, making up the rows of the tables. Users can modify or remove the table at any time using ALTER and DROP commands.

Data manipulation involves the operations that modify the contents of each table. These operations include the INSERT command for entering new data, UPDATE command for modifying existing data entries, and DELETE command for deleting entries from the table.

This characteristic refers to the process of querying the database for specific data based on a user’s specification. Data querying is performed using the SELECT command.

Relational databases offer access control commands to restrict users from viewing or modifying certain tables, columns, or rows. This is done through the GRANT and REVOKE commands.

Data integrity should always be maintained to ensure that the database remains consistent, accurate, and reliable. PRIMARY KEY constraints and FOREIGN KEY constraints are implemented to enforce data integrity and establish relationships between tables, which enforces the reliability of each data record.

Graph model databases like ArangoDB stores entities as collections, which are equivalent to tables in RDBMS (Belgundiet al., 2023; https://arangodb.com/graph-database/). Within each collection (table), there are multiple documents, which are parallel to records in RDBMS. Documents can contain single or multiple attributes. Unlike RDBMS, ArangoDB does not require schemas, in the sense that each attribute must be defined, to build an entity. Documents can be directly entered into collections. There are two types of collections in ArangoDB, which are document (vertex) collection and edge collection.

Document collections, also known as vertex collections, are analogous to data tables in RDBMS. Vertex collections store the collections (tables), which are the primary data elements of the database. Keys are assigned within collections, such as _key, _id, and _rev, and are equivalent to primary key referencing, foreign key referencing, and document revision maintenance respectively. Meanwhile, edge collections are analogous to data relations in RDBMS. Every relation that links one collection to another are stored in edge collections.

These vertex and edge collections are represented as graphs in graph-based models like ArangoDB. Documents from both vertex and edge collections are represented as a node/vertex in a graph. Meanwhile, the relations between each collection are represented as edges in the graph. These edges will use _from and _to components to identify the direction of relation. Storing databases as graphs offers a user-friendly approach due to its intuitive representation of data and relationships.

Like other databases, each graph database has its unique query language. For ArangoDB, ArangoDB Query Language (AQL) is used (https://docs.arangodb.com/3.11/aql/data-queries/). Users can modify existing collections and documents by using 5 different modification queries. Firstly, INSERT allows users to enter new documents into a collection. UPDATE modifies existing documents in the collections, while REPLACE complete replaces existing documents with new ones. UPSERT, a combination of update and insert, is used to insert a new record if the specified unique key does not exist or update the existing record if it does. This is an efficient way to check for the existence of the document without explicitly checking for it. Lastly, REMOVE deletes documents from a collection.

Data retrieval on ArangoDB is carried out with the RETURN command.

Graph-based models like ArangoDB assigns user roles from the Access Controls page in the navigation menu (https://docs.arangodb.com/3.11/aql/data-queries/). Pre-defined roles created by ArangoDB and group related permissions are available for use. Users can also create new roles for other restrictions.

Data integrity on graph-based models like ArangoDB are reinforced with edges and _key commands. This ensures rules governing relationships between vertices are strictly followed.

Wide column stores also known as column family stores are implemented to address the needs of distributing massive amounts of data across different systems (https://www.scylladb.com/glossary/wide-column-database/). They group data by tables, rows, and dynamic columns where every row can contain a different number of columns. This structure has the advantage of flexibility in their storage and thus makes it possible for wide column stores to be applicable in applications that are represented by changing models of data. One main example that can be outlined is the AstraDB that is a serverless vector-based database developed on the basis of Apache Cassandra (https://python.langchain.com/v0.2/docs/integrations/vectorstores/astradb/). A kind of wide-column store which is highly scalable and is primarily designed for the distributed data centre. It is scalable as it deals with petabytes of data and has high availability because of the distributed nature of the system. Their schema flexibility makes them suitable in applications such as real time analysis, time series data analysis and data warehousing since they perform well in data manipulation as well as retrieval of data (Akhtar, 2024).

In a column store like AstraDB, data is stored in column families, where a column family assumes the role of a table in a relational database. Each column family can contain any number of columns, and it is possible to add a new column family dynamically, without extending the length of the rows (Akhtar, 2024). This characteristic makes it possible to store sparse data that are characterized by many empty locations with minimum storage space. To create the column family in AstraDB, the operation used is CREATE TABLE and the columns are created along with their data types. They also define primary keys, which uniquely identify each row in the table.

Data manipulation in wide column stores refers to the operation of inserting, updating, and deleting data within the column families. AstraDB performs these operations using CQL, which stands for Cassandra Query Language (Vohra, 2016). The INSERT command is used to insert new rows, the UPDATE command is used to update the existing rows, and the DELETE command is used to delete rows or a specific column from a given row. These commands make it possible for the database to have high write throughput per second, and at the same time, have high performance.

Data retrieval in wide column stores is optimized for read-heavy workloads. AstraDB uses the SELECT command to query data. The schema-less nature of wide column stores allows for flexible queries, where users can retrieve entire rows, specific columns, or ranges of columns (Vohra, 2016). Indexes can be created to improve query performance, ensuring efficient data access even in large datasets.

Another feature in wide column stores is the ability to control access to the data, thus preventing anyone who is not authorized from accessing the data. From the study conducted on AstraDB, it was observed that the access control model implemented was the role-based access control (RBAC) model (DataStax, 2024). Users have privileges that may include viewing or writing onto specific column families of the key space. These include the GRANT and REVOKE statements which help in enforcing the permissions in order to limit the users who execute some tasks (DataStax, 2024).

In wide column stores, the data integrity is ensured by the consistency levels and replication. AstraDB as a database supports different levels of consistency, which means that users can set priorities to converge on consistency instead of availability and vice versa (Kitterman, 2024). To provide protection against loss of data and to make the data more durable, it is replicated over the nodes. Primary keys and unique constraints also play their role in keeping the record free from redundancy and any adverse effects on the accurate collection of data.

Key-value stores which also fall under the category of NoSQL databases are the simplest, and the data is stored in the form of key-value pairs. It gives an extremely high data access speed, and it can be useful in any application that requires fast lookups such as caching and session handling (https://aerospike.com/what-is-a-key-value-store/). One of the examples of key-value stores is Redis. It is a concern system implemented as a key-value store, which is suitable for various purposes due to its efficiency. It is compatible with almost all types of data and has many extras such as transactions, pub/sub, and Lua scripting. It is widely implemented in caching, probably in session handling, and in real-time analytics applications in which real-time data is vital (https://aerospike.com/what-is-a-key-value-store/).

The data in key-value stores such as Redis is stored in the form of a key-value pair where the key is unique and is associated with a specific value. It can be any type or kind of data inclusive of strings, hashes, lists, sets, sorted sets, etc. For the creation of data, the SET command is utilized, before which a value is assigned to a key (https://redis.io/nosql/key-value-databases/). Directions are rather unique labels in the database while extents are linked with these directions without reference to a pre-designated structure. Redis’s flexibility makes it suitable for a wide range of applications because it allows it to handle different data types and structures with ease.

Manipulation in key-value stores signifies creating, updating, and deleting key-value pairs. SET is one of the commands that allows the setting or updating of a key-value pair while DEL is a command used in the removal of a key as well as its value (Kaur and Kaur, 2018). These bench operations are highly efficient and prompt with the result that key value stores perform well in read and write operations. The high-performance demands of modern applications depend heavily on these techniques’ efficiency. Redis uses advanced techniques to improve the speed and effectiveness of these processes, including instruction-level parallelism and cache-friendly hash index structures (Kaur and Kaur, 2018).

Similarly, data retrieval is quite easy in key-value stores as there is no complex model as presented in other databases. GET is one of the interrogation commands whereby Redis helps in retrieving the value of a specific key typed in. Due to their high efficiency, key-value stores are used in applications in which the speed of data access is paramount (Kaur and Kaur, 2018). Redis’s effective caching and in-memory data structures improve retrieval performance significantly. Redis can be used for use cases including real-time analytics and caching, which require quick access to data and low latency.

The authorization which takes place on the key-value stores, can be achieved mainly through the identification of a user and the functionalities that have been granted/restricted. For instance, Redis has a configuration file when it comes to the authentication of the roles of users (Liu, 2019). These roles can specify which command is available to the given user, and thus they can deny access to the required information. This access control system is very important when it comes to ensuring that the private information is secure and only those who are allowed can perform some operations. These security features complement Redis’s security features such as RBAC and encryption activities to boost the security of the platform.

It is important to maintain the consistency of the data in key-value stores and this can be achieved through persistence and replication. The advantages of Redis include a snapshotting with a fast data persistence and Append-Only File (AOF) (Liu, 2019). Replication also assists in the copying of data from one instance to another hence its availability in case of failure. Redis cluster availability and dependability are further improved by innovative techniques like the dynamic cuckoo filter system.

A NoSQL document-oriented database such as Apache CouchDB stores data in JavaScript Object Notation (JSON), Binary JSON (BSON) or eXtensible Markup Language (XML) document (Sadalage and Fowler, 2012). Document-oriented database stores their data in a collection of documents (Olivera,et al., 2019). This is completely different from RDBMS where the data is stored in a table with rows and columns. Document databases are known to be flexible and scalable. This is because they do not require a fixed schema. In other words, different documents in a collection can contain different types of data and each document can have a different data structure within a collection (Patel, 2024). Additionally, new data can be added to the document without affecting the pre-existing documents.

For CouchDB, a database can be created by selecting “Create Database” from the Fauxton interface. Fauxton is the default administration interface used by CouchDB that allows users to manage their databases and documents. Once a database is created, the “New Doc” function will allow the user the create a new document (https://docs.couchdb.org/en/stable/intro/tour.html). Another method is through the client URL (cURL), a command line tool that allows access to the HTTP protocol. A database can be created through this method by using the PUT operation. Similarly, the PUT operation can also be used to create a new document (https://docs.couchdb.org/en/stable/intro/curl.html). Each document in CouchDB is uniquely identified by its _id field. This _id field is used as a primary key to identify the different documents. As a fixed schema is not needed, a new field can be added within a document by using the editor provided in CouchDB (https://docs.couchdb.org/en/stable/intro/tour.html).

Data manipulation techniques to update and delete the data can be done using the Fauxton interface or via cURL. As for updating the document, the PUT operation can be used to send a HTTP request to the server (https://www.tutorialspoint.com/couchdb/couchdb_updating_a_document.htm). Deleting a document works in the same manner but it uses the DELETE operation (https://www.tutorialspoint.com/couchdb/couchdb_deleting_a_document.htm). A notable feature that document-oriented database can do is to attach files like pictures to the document. This can be done by using the PUT operation and including the relevant information such as the document ID, the name of the database and the name of the attachment (https://docs.couchdb.org/en/stable/api/document/attachments.html).Data RetrievalData retrieval in CouchDB can be done through the cURL utility. The HTTP GET command can be used to retrieve the data within a document by specifying the unique _id in the URL (https://docs.couchdb.org/en/stable/intro/curl.html).Access ControlThere are different methods in CouchDB to give a user permission to access certain databases and documents. The straightforward method is through the Fauxton interface where users would have to click on the “Permissions” section and set it to their preferences.As for the cURL method, there are basic authentication measures in place. By adding the admin’s username and password in the URL, CouchDB can determine if the user is authorized to access the document. There are two main roles on CouchDB, namely admin and member. Admins have full control over database that they are administrating and are able to change users’ roles while members can read, create and modify document but are unable to modify the designs of a documents such as the views and indexes. The permissions of a database can be modified through the command line by editing the security document within the database (https://docs.couchdb.org/en/stable/intro/security.html).Data IntegrityCouchDB has several data integrity controls in place, namely, Multi-Version Concurrency Control (MVCC) and data validation. Traditional database can only be modified by one person at a time, the person who is editing holds the “lock” and everyone else must wait for the “lock”. This method is known as locking. On the other hand, CouchDB uses MVCC, a method that creates multiple versions of the document and allows simultaneous access to the database while maintaining full speed. This method ensures that data is consistent as it prevents conflicts. Moving on, data validation is performed by CouchDB through the use of JavaScript functions. This process ensures that only valid data modifications are allowed, thus maintaining the overall data quality and consistency (https://docs.couchdb.org/en/stable/intro/consistency.html).After continuous research synthesis, Table 2 is created to depict the distinct characteristics and features summarized for easier readability.

Reviewing Existing StudiesThere are many existing studies that analyze the compatibility of different database models in the retail industry. For example, retail stores with a lot of data to process would be more suited to use document databases such as MongoDB instead of traditional SQL databases (Rameshet al., 2016). The research states that NoSQL databases show higher flexibility and scalability, which makes them the preferred database model for online retail industries. This is because document databases provide more flexibility in schema implementation as schemas are not necessary. In fact, document databases, like other NoSQL databases, normally operate by populating the tables before checking for constraints (Soares, 2015).Additionally, other research concludes that graph databases like ArangoDB benefit the e-commerce industry. This is because graph databases are built to handle large volumes of data, and they can manage the relationships between the data effectively through building knowledge graphs. Unlike the traditional relational database that use tables and joins, graph databases use nodes and edges. This makes it easy to process complex queries in real-time (Yeunget al., 2018). This is supported by Thakare et al., (2023) whose study revealed that NoSQL databases are suited to handle and analyze large volumes of data generated by e-commerce platforms.Furthermore, wide-column and key-value stores are essential in retail and commerce fields due to the scalability of data and usage of efficient structures in applications. Wide-column databases, like Astra DB (Cassandra), are useful for huge datasets keeping in mind the scalability and distribution of the data among many nodes (Agrawalet al., 2024). These databases are well suited for applications where raw processing power is needed, for instance, in real-time analysis of e-commerce platforms. Essentially, key-value stores such as Redis are simple and fast, which can be appropriate in caching and session use cases in retail applications. These models enable the variation of the data that is stored and their accessibility, which is essential in e-commerce data such as product lists, customer transactions, and orders. According to research, wide-column and key-value databases can also greatly improve efficiency in cases of large-scale, reads, and real-time data processing (Reddy, 2024).In short, most existing studies conclude that NoSQL databases are more suited for large volume retail databases. This study aims to add on to these current findings by identifying the optimal database for online retail industries.MethodologyIntroduction

Initially, an outline was created to provide structure to the introduction. This outline splits the introduction into four sections that focused on different aspects. These four sections include the background of e-commerce and retail, importance of data in retail, challenges of data management and the research questions of this study. The team gained key insights for these topics by reading various database management academic papers that were relevant to the e-commerce and retail industry. Other sources that were referred to by the team include journal articles and books. Key points from the academic materials were extracted and compiled to form a draft for the introduction. These points were also supported by relevant statistics and real-world examples found in the materials. The research questions and objectives were decided after thorough research and discussion among team members, ensuring that they are directly relevant to the research title. Multiple revisions were made to ensure clarity, consistency and adherence to academic writing standards throughout the writing process.

Literature analysis was carried out to identify and understand the different model types. Firstly, researchers identified the useful research papers by browsing through online academic databases such as Google Scholar and Tun Hussein Onn Sunway Library. Researchers then used specific keywords such as “Database Model Comparison” and “Retail” to obtain the most relevant journals that aid in the comparison analysis for this research paper. These journals were then checked for their credibility by ensuring that they have been peer-reviewed and are not too dated. After that, researchers carefully read through every article to identify the common and contrasting themes mentioned throughout the papers. These findings were synthesized and documented in the paper later on. This thorough investigation helped highlight the differences between SQL and NoSQL databases, which helped researchers gather more comprehensive insights into the how different database models affect CRUD operations, access controls, data integrity and other aspects.

Sample databases were created after reviewing data structures and Entity Relationship Diagrams (ERDs) that focused on order processing and customer relationship management from existing studies. The selected database models are as follow: Oracle APEX for Relational, ArangoDB for Graph, AstraDB for Wide-Column, Redis for Key-Value, CouchDB for Document. Each database approximately had 200 – 1000 records on each table that will be applied and inserted using JSON files and the command languages of the respective database model to compare between the different database models. Once the databases were established, queries narrating various scenarios were made and implemented to evaluate the performances of each database model in applications [Appendix A]. Apart from capturing the performance indicators provided by the database model, performance indicators from “Task Manager” on laptops were also recorded and summarized into concise graphs to contrast each database model in various aspects.

The discussion section consists of a comparison analysis between the five database models. It analyzes the key aspects such as data creation, manipulation, retrieval, access control and data integrity of each database model and how they compare to one another. The aim of this discussion is to identify the strengths and weaknesses of each database model under different scenarios that are relevant to the e-commerce and retail industry. Additionally, the discussion answers the research questions introduced at the beginning of this study by reflecting on the findings gained from the comparative analysis and correlating it with the results obtained from the experiment.

The conclusion compares the result of our study to other existing studies that were mentioned in the literature review. It highlights how our results either contradict or support the previous studies and explores the reason behind this. This section also mentions the insights gained and lessons learned by our team during the whole process. The limitations of the study as well as potential future avenues of our research will also be mentioned in the conclusion.

The following results depict how each database model executes data creation, data manipulation, data retrieval, access controls, and data integrity in different scenarios. The tables were populated with over 1000 records. These records were randomly generated using a Python program [Appendix B]. The constraint schema used are also documented in this report [Appendix C].

The first scenario-Order Management Database, is used to reflect real-world situations where thousands of data are used in a customer order database. This database consists of 4 tables, which are the User, Goods, Order, and OrderGoods table. This database was adopted from a prior case study by Wei and Zhang, (2018).

The second scenario used in this report is a Customer Relationship Management (CRM) Database. This database is used to depict the data management for the reviews and complaints given by online customers. It consists of 7 tables, which are Company, Office, Coworker, Person, Deal, History, and Document. These tables were adopted from previous research in Sweden (Winberg and Zubac, 2019).

The performance of each database model is based on CPU utilization, speed, and memory usage. The full screenshot of the performance is documented in the appendix [Appendix D-H]. Performance in terms of seconds taken for server platform to execute query is not documented as not all database models have that feature [Appendix I]. Hence, for consistency, only these 3 features are used to assess the performance.

Figures 1–6 illustrate how relational databases are leading in terms of various performances. They highlight how Oracle utilizes low CPU space, high speed, and higher memory usage.

Figure 1:
CPU Performance for Data Creation Across All Database Models.

Figure 2:
Speed Performance for Data Creation Across All Database Models.

Figure 3:
Memory Usage for Data Creation Across All Database Models.

Figure 4:
CPU Performance for Data Manipulation Across All Database Models.

Figure 5:
Speed Performance for Data Manipulation Across All Database Models.

Figure 6:
Memory Usage for Data Manipulation Across All Database Models.

For CRUD operations, it is clear that Oracle again shows better performance overall compared to the other database models, as shown in Figures. Relational databases use lower CPU storage; have higher processing speed, and high memory usage.

Figures 7–9 display Oracle and ArangoDB as similar performing databases for data retrieval. This is because ArangoDB shows inefficient CPU usage, with higher speed, whereas Oracle uses less CPU usage and lower speed. Other NoSQL databases such as column (AstraDB) and document databases (CouchDB) have no performance available as they do not support view functions, which is what the query contains.

Figure 7:
CPU Performance for Data Retrieval Across All Database Models.

Figure 8:
Speed Performance for Data Retreival Across All Database Models.

Figure 9:
Memory Usage for Data Retrieval Across All Database Models.

Figures 10–15 highlight ArangoDB as the database model with the better performance overall. This is because of the efficient utilization of CPU, the higher processing speed, and the comprehensive usage of memory storage.

Figure 10:
CPU Performance for Access Control Across All Database Models.

Figure 11:
Speed Performance for Access Control Across All Database Models.

Figure 12:
Memory Usage for Access Control Across All Database Models.

Figure 13:
CPU Performance for Data Integrity Across All Database Models.

Figure 14:
Speed Performance for Data Integrity Across All Database Models.

Figure 15:
Memory Usage for Data Integrity Across All Database Models.

Figures display Oracle as the better performing database models due to its lower CPU utilization, and higher memory usage. Even though it has relatively lower speed compared to the other database models, it still exceeds in performance from an overall view.

Overall, Oracle shows the best performance in terms of memory usage, CPU usage, and speed. To dive deeper into the strengths and weaknesses, Table 3 shows the characteristics of each database model observed in both scenarios.

Relational databases are known for their robust data integrity and ability to handle complex queries, primarily due to their rigid schema design and enforcement of constraints. However, these same features can become limitations when dealing with large datasets, as performance may decline, and the inflexible schema can make adapting to changes challenging. On the other hand, graph databases stand out for their powerful querying capabilities enabled by flexible schemas and the use of AQL (ArangoDB Query Language). Despite these strengths, they come with a steep learning curve and may require ongoing performance tuning, especially as dataset sizes increase.

Wide Column stores, like Cassandra, are designed for high write throughput and straightforward data operations, making them ideal for applications requiring fast, large-scale data processing. Yet, their simplicity in handling queries means they struggle with more complex data manipulation tasks, often necessitating additional setup and management efforts. Key-value stores excel in scenarios requiring rapid processing and retrieval, especially in batch operations, but they lack built-in data validation and the ability to perform complex queries, which can limit their use in more sophisticated applications.

Lastly, document databases offer a great deal of flexibility in schema design and ease of data creation, particularly for unstructured or semi-structured data. However, this flexibility comes with a trade-off as it can lead to data inconsistencies without careful management. Hence, it is crucial for users to implement stringent data validation practices. Overall, each database type has its unique strengths and challenges, and the choice of which to use depends largely on the specific requirements of the project or application.

The objective of the section is to present a thorough analysis of the results which compared the 5 database models-relational, graph, wide-column, key-value, and document-with emphasis on how well these models work in the retail industry, specifically for optimizing order processing and Customer Relationship Management (CRM).

To aid in answering the research questions defined in the Introduction section, a table which discusses the key aspects of each of the 5 database models is as shown in Table 4.

Relational databases like Oracle APEX are optimized in data consistency and integrity through structured schemas and SQL constraints. This makes data creation and manipulation simple in Oracle APEX, but also contributes to the inflexibility of the database. Graph databases like ArangoDB offer flexible schemas and are more semi structured. ArangoDB has adequate capabilities when it comes to dealing with complex data relationships, which is ideal for highly relational applications. Wide-column databases like AstraDB, which is built on Apache Cassandra, provide high write throughput and efficient bulk data operations. However, it does not handle complex operations well and need to be processed using application logic such as Python. Key-value databases, such as Redis, offers fast data creation and retrieval through key-value stores with the use of basic data types like simple key. However, it lacks features for complex data manipulation and validation. Document databases like CouchDB supports flexible document schema and handling of nested data. However, its operation may be slower in complex data manipulations as it relies heavily on MapReduce.

Relational databases like Oracle APEX are efficient for data retrieval and have an effective querying language know as SQL. However, it is not suitable for complex querying capabilities on large datasets. Graph databases like ArangoDB are highly efficient in querying complex data relationships. It is particularly useful for hierarchical and networked data retrieval. Wide-column databases like AstraDB are mostly designed for read-intensive workloads on large datasets. It lacks support for complex join operations and queries which need to be handled at the application level. Key-value databases like Redis are highly efficient for simple-based queries. It is ideal for caching but are not suitable for looking up complex queries. Document databases like CouchDB are good for retrieving nested and hierarchical data. However, it is inefficient for looking up data due to its need for indexing and MapReduce operations.

Relational databases like Oracle APEX provide robust access control and high data integrity using constraints which can be defined using SQL. Graph databases like ArangoDB offers a flexible way to implement access control. It also supports data integrity through application-level enforcement. Wide-column databases like AstraDB enforce primary key constraints through partition keys. It provides role-based access controls but requires data integrity constraints to be managed at the application level. Key-value databases like Redis mostly provide simple access control and has minimal data integrity enforcement. It focuses more on performance. Document databases like CouchDB support flexible access controls. It ensures data integrity through unique document identifiers but lack built-in constraints.

Based on the comparative analysis, the most suitable data model for the different key aspects of required for e-commerce or online retail industries is summarized in Table 5 below:

Based on the results section, the various types of database models analyzed suggest different capabilities for managing large volumes of transaction and operations in retail and e-commerce. Each database model presents its unique strengths, but three database models stand out in this area:

Wide-column databases such as AstraDB are suitable for volume transactions due to its ability of high write throughput, of handling bulk data and for horizontal scaling, which is crucial for handling the large data loads which are common in retail and e-commerce applications. The database is designed to handle large-scale applications with massive volumes of data that requires frequent read and write request. AstraDB has a user-friendly web interface which allows each data creation and load with support for CSV files and data migration from DynamoDB, which is beneficial for large-scale retail operations that require fast data loading with high scalability. Additionally, AstraDB which is built on one of the most popular wide-column databases, Apache Cassandra, uses CQL (Cassandra Query Language), which has similar syntax to SQL. This simplifies data manipulation for users that are familiar with relational databases. However, it comes with the limitation that CQL lacks support for complex operations and requires them to be handled at the application level such as using Python.

Using key-value databases like Redis can be useful in high transactional environments, specifically in caching, session management, and simple-key operations. Redis features an in-memory data storage which can help ensure low latency, and this makes it suitable applications which requires rapid read and write operations, which is critical for real-time processing needs in e-commerce platforms. For instance, Redis has the ability to process 1000 records in just 0.725 seconds, and this highlights its efficiency in handling bulk operations. However, it comes with the limitation that it lacks advanced data manipulation capabilities and query support, and this limits its use for simple and more straightforward operations, limiting the range of operations needed in complex retail scenarios.

Document databases such as CouchDB are well-suited for high volume operations. It is highly efficient in dealing with nested documents which are fairly common in e-commerce or retail applications especially when dealing with diverse product catalogs and user or customer profiles. CouchDB allows for flexible document structure and does not require the need for predefined schemas, which is beneficial for applications that require high scalability, making it suitable in accommodating the dynamic nature of retail data. CouchDB uses MapReduce functions for querying and indexing for efficient data retrieval which is crucial for large datasets. However, it is noted that users must familiarize themselves with the functions to be able to manage the database effectively. Other than that, CouchDB has the ability to JSON documents through its user-friendly access management through the Fauxton interface. This makes it highly suitable for e-commerce applications and scenarios which demands high flexibility.

In conclusion, the best database model for high volume transactions and operations in retail and e-commerce depends on the specific use case, but generally the three database models discussed present the best performance and their key strengths along with its limitations is summarized in Table 6 below:

In short, the selection of the right database model for high volume transactions and daily operations in the retail and e-commerce industries will depend on the needs and preferences of individual businesses. Wide-column databases such as AstraDB perform well in write throughput and work well in a setting that requires loading large amounts of data and processing them quickly, but do not support detailed operations without further application-level enjoyment. Some of the popular NoSQL databases like Redis are great for real-time data processing and caching since they store data in memory but are not very good at querying. CouchDB based document databases are flexible and easy to manage with nested documents and can handle dynamic structure of retail data while they are functioning but one needs to understand MapReduce functions. All the models have their own advantages and disadvantages in stability, query complexity and data manipulation. Hence, the selection will depend on the requirement of scalability and the query complexity of the retail or e-commerce application in question.

In conclusion, each database model possesses different characteristics that impact data creation, manipulation, retrieval, access control, and integrity. To answer the research questions, relational databases appear to be the most suitable database model for conducting data creation, manipulation, retrieval, access control, and integrity. Meanwhile, online retail organizations are encouraged to select NoSQL databases if they seek models solely for high performances. Overall, relational (SQL) databases prove to be the best performing database model while balancing high volume transactions and operations in retail and e-commerce. This is because compared to NoSQL databases, relational database easily allows for the creation of views and indexes. These features are vital for the easier data management and access in the e-commerce industry where tons of data are collected. As a result, the online commerce industry will greatly enhance database management performance by implementing relational databases such as Oracle throughout the company.

These findings greatly contradict prior research where NoSQL databases such as graph and document models are suggested for higher management efficiency (Ramesh,et al., 2016; Thakareet al., 2023; Agrawalet al., 2001). Even though this research has contrasting conclusions compared to other research papers, it does not mean that one is incorrect. This is because different scenarios and industries will require different database models, according to their respective needs. Hence, this report concludes that relational databases would be preferred in the retail industry because SQL databases will impose strict data integrity constraints, while other NoSQL databases do not.

This conclusion does not imply that another research is incorrect. Instead, it highlights how different database models cater to varying needs. It is up to researchers to determine which database model best suits their objectives in terms of performance and scalability. To maintain strict data integrity and consistency, relational databases would be the best choice for online retail industries.

Moving on, this report further added to existing studies by highlighting the efficiencies of relational database models when compared to NoSQL models, showing how the lack of features such as access controls, views, and join functions will impact the decision on the preferred database model in a retail industry. This is one of the reasons why relational databases are preferred in this research study even though NoSQL databases have a more flexible schema validation, data creation, and table population. This study also contributed information on the workings of different NoSQL databases such as ArangoDB and AstraDB as not much study has been conducted on these database models.

This study has made the realization that there is no such thing as a best database model. Instead, there is the better performing database model that best suits the needs and objectives of an organization. Therefore, database managers must constantly evaluate the objectives in relation to the schema, data type, and data volume of a database before deciding on the database model to use. We learned that to be a database engineer or relevant roles, one must be meticulous and patient when handling a database to ensure that the database model will align with company needs. Furthermore, we have also learned the importance of balancing flexibility with data consistency. This is because although relational databases have higher data consistency due to strict constrain rules, they lose out on the flexibility of data handling compared to NoSQL database models. Hence, understanding this concept will allow researchers to have clearer understanding on which database model to use in specific scenarios. As a result, this paper allowed us to enhance our understanding in both SQL and NoSQL database models.

Lastly, the team has also learned the importance of refining current database knowledge to keep up with current world changes. By keeping an open mind to learning new things, the team is more prepared to handle changes in the database industry. With the report, we have also enhanced our experience in team collaboration as we consistently maintained clear communication with each other. Each member has learned to balance our personal tasks with this report, ensuring that every deadline is met consistently. As a result, the time management skills of each member are also greatly increased to maintain the consistent work pace in completing this research paper.

One of the limitations of the study is the usage of different devices with varying specifications. Due to location constraints, the team utilized their own personal laptops with different hardware configurations to test the performance of the database that they were assigned to. Different devices have different RAM and CPU that affect the performance rate of the database. This difference in hardware may have led to inconsistencies in the database performance result. Additionally, another limitation is that our research only focuses on two main scenarios specifically for the retail industry which are company supply order management and CRM of a company. Other studies that utilize these database models while focusing on other industries such as healthcare, may yield different results due to differences in data volumes and other factors. Furthermore, the team’s lack of proficiency with their respective databases is another one of the drawbacks of the study. This is because this was their first time using the database; thus, they were faced with a steep learning curve. Thus, this leads to user errors and inefficiencies in managing the database. Despite these limitations, the findings from the study provide a deeper understanding of the strengths and weaknesses of each database model in the retail industry.

Future research in this field could focus on the database models’ performance under larger volumes of data. Researchers can identify at which point does the database model begin to experience a decrease in performance. This will allow researchers to determine the limitations of each database model and identify the best-performing model for large datasets. One aspect that was not tested in this study was the database models’ backup and restore functions. Future investigations can be conducted to determine the frequency of the backup system and how it impacts the database model’s performance. Additional studies can be carried out to identify the time taken to restore the data as well as to what extent and how far back in time data could be recovered. The study of the backup and recovery system would benefit organisations as they would be able to make well-informed decisions when choosing the database model that would suit the needs of their own organisation. Moreover, it would be beneficial to research the ability of the five database models to process and query real-time data. This would be incredibly useful for the e-commerce and retail industry where data is constantly generated. Processes like inventory management, order processing and customer behavior analysis would benefit from real-time data processing as it enables the organisation to make quick decisions that may potentially affect their market positioning. Overall, researching these areas would provide further insights into the potential of each database model.