ProductsLogo
LogoStudy Documents
LogoAI Grader
LogoAI Answer
LogoAI Code Checker
LogoPlagiarism Checker
LogoAI Paraphraser
LogoAI Quiz
LogoAI Detector
PricingBlogAbout Us
logo

Database Consistency and Integrity

Verified

Added on  2019/10/12

|20
|7712
|261
Report
AI Summary
The provided content includes a range of research papers and articles focused on various topics such as database systems, SQLite optimization, mobile applications, and computer security. The papers explore different aspects including lightweight application-level crash consistency, I/O scheduling in Android devices with flash storage, SQLite optimization with phase change memory for mobile applications, and device-specific Linux kernel optimization for Android smartphones.

Contribute Materials

Your contribution can guide someone’s learning journey. Share your documents today.
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Aims of the Project
The goal is to evaluate the SQLite database issues on web based database challenges
Objectives
This paper provides the details about the SQLite and the challenges using the SQLite in the
web based database. Here we will investigate the risk associated with the SQLite. The
requirement of web based database.
Abstract
Today’s dynamic and rapidly evolving nature of systems enforces the special requirements on
the technology, the approach to solve the system, architecture and design of the
computational structure which include the database and Web application both. Now we have
multiple solutions to suggest meeting the prospects and innovative functionality have been
established to discourse the persisting problems of web based database challenges. It is
beneficial for us to comprehend multiple technologies and multiple approaches. To habituate
with the profit and loss of the existing technologies, the investigators can check its abilities.
Here In this review we are going to discuss the current issues with the SQLite database in
terms of web based database challenges (Ashenfelter, 1999).
We will discuss about the SQLite (what is SQLite, How it work, and the architecture of
SQLite) why it is not appropriate with the web based database, what is the difficulties we
handle when we use SQLite as web based database. What are the challenges in web based
database. The problem of using the server less architecture using in SQLite, the benefits of
using the client server architecture, how the file licking system affects the performance of the
SQLite database, Why it is suitable for the small application like mobile app, iPhone, and
other android apps, What types of problem we faces while we use SQLite in a large volume
website database, Why the SQLite failed in high volume concurrency data handling, why the
file of database is failed in sync Describing the file over writing problem. But before
discussing all first we need to understand what is SQLite, how it work, and what are the
challenges of today’s web base database and how we can overcome from this type of
challenges (Ungaro et al., 2017).
1 | P a g e

Secure Best Marks with AI Grader

Need help grading? Try our AI Grader for instant feedback on your assignments.
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Keywords: multi-writer, multi-reader, client/server, self-contained, server less, transactional,
zero configurations, light weight, TCP/IP, Data security, Data safety, thread, multi thread,
architecture, High availability, File locking, memory, database corruption, Error,
Introduction of SQLite:
First we need to understand what is SQLite then we discuss about the current issues with
SQLite. It is a software collection of archive file or library which offers a RDBMS. The Lite
in the SQLite means lightweight, SQLite is very light weight when we are going to setup,
DBA etc. SQLite is a server less database, a self-contained, has zero configuration, and
transactional (Ahmed, 2015).
Server less
In general every relational database (for example MYSQL, SQLSERVER, PostgreSQL, etc.)
requires the server for operations. Because the database application needs to contact the
database server to use TCP/IP protocol, using this database can receive and send requests. It
is known as client/server architecture. But in the SQLite there is no need of server and it is
called server less database (Nwachukwu, 2012).
RDBMS client/server architecture:
SQLite database is associated with the user application software which contacts the database.
Application software will interrelate with the SQLite database and access the database file
from the disk directly (Kreibich, 2010).
2 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
SQLite server-less architecture:
Self-Contained
Self-contained like independent, SQLite is self-contained, it require marginal or minimum
maintenance from the external library or the operating system. That’s why it’s useful for the
embedded devices like iPhones, android phones, and handheld media players etc (Alvaro,
2016).
Zero-configuration
SQLite has no server it is server less architecture so it does not requires server, and also no
need to be configured, started, and stopped (Pereira, 2009).
Transactional
SQLite is totally ACID compliant, the requests (query) and variations are Atomic, Consistent,
Isolated, and Durable (Min,Kang, Kim, Lee, & Eom, 2015).
Overview of web based database challenges:
Today we have a number of databases available, all database have own advantage and
drawbacks, The perfect technique to decide the correct database for our desired requirement
is to decide our self , the challenges we have, and what we need in our database to
meet? (Mitrovic, Suraweera, Martin, & Weerasinghe, 2004).
Followings are some common database challenges and the solution to overcome this type of
problem:
3 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
1. Data security
In the recent years we have multiple examples of website or system hacked due to the
database is totally unprotected on the internet (publically).The irony is that the databases
weren’t stranded due to the safety issues. Now the databases come with the security which is
informal to set up, fast to inform the users if anything is going incorrect (Stallings, Brow,
Bauer, & Bhattacharjee, 2012).
2. Performance
In terms of performance we can see in the recent year the database continuously challenged
tough working standards. The quantity of data we are taking in may be increasing, but to
gratify our customer or user we require its processing faster, without creating them to hurdle
over hoops to get there. A good database designed be made for good concert, irrespective of
the hardware. If it will perform well on machines, it has good “native” performance
(Florescu, & Kossmann, 2009).
3. Data safety
An information is always require to be treated in a technique that guarantees zero loss. Even
in a non-relational database, they must have ACID assurances both the database and cluster.
The main test for any database is in the working criteria. A noble database is always gives us
the good performance as well as the transactional guarantees (Cheung, Cheung, & Suen,
2004).
4. Resource utilization
In terms of web based challenges we always assumed that database run on a best available
hardware and behave accordingly. To preserve the performance in the restricted calculating
capacity and they will tackle vast quantities of composite data, a database needed 100 percent
out of the capitals it is occupied on for each nanosecond it is running (Kavadas et al., 2013).
5. High availability
4 | P a g e

Paraphrase This Document

Need a fresh take? Get an instant paraphrase of this document with our AI Paraphraser
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Suppose we use a database which has only one server and our server drives down, our
business or organisation also goes down with the server. A data cluster which containing of
multiple servers functioning well gives us multiple levels of backup. For organisation, it is
like to connecting additional records to holder the increasing line of customer. A distributed
database can have the situation where the task will be failover so once the node working on a
particular task it drives low, that work or job is routinely moved to a functioning node.
Writing a operation to a local disk is a much quicker than requiring to scuffle it through a
distributed network. Noble database takings this into attention and makes advanced
resolutions to preserve the performance beside with ensuring continually on obtainability
(Pokorny, 2013).
Current Issues with SQLITE
1. Not supported Client/Server Architecture
Client/server application architecture is like a producer and consumer architecture in this
architecture the server act like the producer and client act like the consumer, the server
provides the service to the client on demand. The services can include the access of
application, sharing the file, accesses the printer, or it may be other services. It works when
the client send the appeal to the server, it progress the client request and response send back
to the client, at a time the server can handle the multiple clients simultaneously, the same
time the client is connected with multiple server. When we use the client server architecture
many clients sending the SQL to the same database over the network (TCP/IP), but in case of
SQLite database they work over a network file system, but because of the inactivity related to
the most network filesystems it will affect the performance of the system. File locking
problem is stroller for many applications which uses the network file system implementation.
If in the network filesystem the file locking does not work properly and multiple client access
or try to update the same things (operation) at same time, the result will be corrupted Because
it is the bug of network file system. So it is the current issues with the SQLite when we work
with the client server architecture (Nield, 2016). .
5 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
2. File locking problems
SQLite practices the file locks on the file of database and on the write-ahead log or WAL file.
File lock system organise the contact among the synchronized methods. Because if the
system not coordinate the two or multiple process at a time it will make the incompatible
changes in the database file at the similar or identical period, and we faces the database file
exploitation issues (Owens, 2006).
Followings are some issues with file locking system:
I. Filesystems with broken or missing lock implementations
In the SQLite the lock in the database filesystem is like documentation says it will. But it is
not always the best way to lock the database filesystem, because some time we found the
filesystem contained the bugs in the locking system logic and the lock is not working
properly. It is most common when do not use the client server architecture and go with
network filesystem. When SQLite database file contain any bugs in their locking logic the
multiple thread or process wants to retrieve the same database file at a same time at it leads
the database corruption (Haldar, 2007).
II. Posix advisory locks canceled by a separate thread doing close()
The SQLite uses the defaulting locking process on the unix platform known as POSIX
advisory locking. Some process in the similar method with a file descriptor which is carrying
a POSIX advisory lock will dominate that lock by using a altered file descriptor. Single
predominantly malicious difficult is that the close() system call will stop all the POSIX
advisory locks on the similar file for entire threads and all file descriptors in the method.
Therefore, for example, assume a multi-thread procedure has more than two threads with
distinct SQLite database networks to the identical database file. Then another thread comes
laterally and needs to recite somewhat out of that identical database file on its own, without
using the SQLite library. The another thread prepares an open(), a read() and then a close().
One may be consider this will be inoffensive. But the close() system call produced the locks
thought the database by all the other threads to be released. Other Individuals threads must
have no approach of knowing that their locks have just been disorganized. Remember this is
totally harmless for multiple process to contact the SQLite database file consuming the
6 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
SQLite library. The drivers of unix for SQLite aware of the POSIX advisory locking
coincidences and effort nearby. Difficulty first rises when a process wants to avoid the
SQLite archive and recited the database file straight (Sugiharto, 2010).
To overcome the POSIX advisory locking system on the database filesystem SQLite contains
possession a universal list (mutex protected) of open SQLite database files. But, if we have
various replicas of the SQLite are connected to the identical application, then we have
numerous occurrences of this universal list and the database connection which is unlocked
using the single duplicate of the SQLite library is totally uninformed of database contacts
unlocked by the using of additional copy, and the SQLite is not able to effort about the
POSIX advisory locking quirks. And when we apply the close () operation on one connection
to close that particular connection it will be innocently release the locks on a multiple
database contact, and it will lead to the major database corruption (Ganai, 2012).
The above given scenario is like sounds unbelievable but the people (developer) working
with SQLite are conscious of at minimum one profitable merchandise that was released with
accurately with this bug or issues. The seller came to the SQLite developers looking for
support in chasing down some uncommon database exploitation problems they were sighted
on Linux and Mac. The difficulties were ultimately outlined to the fact that the application
was connecting beside the two distinct duplicates of SQLite. The explanation was to
alteration the application build measures to link beside just one copy of SQLite in its place of
two (Gilbert, 2007).
III. Two processes using different locking protocols
POSIX advisory locking technique in SQLite for unix platform is a default locking
mechanism but we have supplementary choices also like sqlite3_vfs using
the sqlite3_open_v2() interface, using this method we can procedure other locking protocols
which will be most suitable for definite filesystems. For example, dot-file locking system
must be choose for procedure in an application which will be run on an NFS filesystem and it
does not care POSIX advisory locking. But the most significant that altogether the links to the
same database file use the same locking protocol. If one database file application is using
POSIX advisory locks and other database file application is using dot-file locking, then in
this scenario both the applications is not able to see separately other's locks and they will not
7 | P a g e

Secure Best Marks with AI Grader

Need help grading? Try our AI Grader for instant feedback on your assignments.
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
capable to organize database contact, and it leads to the major database exploitation (Long,
2011).
IV. Unlinking or renaming a database file while in use
If multiple threads have open networks to the identical database file and one thread closes its
network, unlinks the file, then it makes a fresh database file in its habitation with the similar
name and reopens the new file, then the two threads will have conversation to another
database files with the similar name. Meanwhile rollback journals and WAL files are
constructed on the name of the database file, the two dissimilar database files will parts the
same rollback journal or WAL file. A rollback or retrieval for one of the databases may use
contented as of the other database, resulting in corruption. The same type of difficulties arises
if the database file is retitled although it is unlocked and a new file is formed with the ancient
name. In other way we can say the not linking or change naming of an open database file
outcomes in performance that is indeterminate and perhaps unwanted (Pillai et al.2014).
V. Multiple links to the same file
Only database file has numerous associations then we can say they have several names. If
multiple threads create the database by means of multiple titles, it usage multiple rollback
journals and WAL files. Means one process smashes, the supplementary threads is not able to
get well the operation in improvement since it watching incorrect habitation for the suitable
journal. In different terms, foundational and consuming a database files which multiple title
outcomes in performance that is indefinite and perhaps unwanted (Leschke, & Nicholas,
2013).
3. Not supported by High-volume Websites
SQLite database performance is good when it is work with as the database backend to a
website. But if the website is write-intensive or is so busy that it requires multiple servers,
and then we choose the client server architecture instead of SQLite. Because concurrent or
multiple writes not allowed in SQLite, and for high volume website we need multiple
concurrent writer and in case of SQLite we have only single writer, multi reader. And it’s
beyond the SQLite design. For high volume website it is hallmark to use the large engine
database for example DB2, ORACLE, SQL Server, PostgreSQL etc. SQLite opted a very
different design philosophy from the most of the different design philosophy from the most
server centric DBMS which support the multiple reader with multiple writers. SQLite is
8 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
designed to take the power of SQL (Structured Query Language) and the relational model to
individual applications, and definitely to be embeddable within each application. It’s not
adding the important infrastructure and overhead needed to handle multiple concurrent
writers is one of those (Huang, Guo, Zhang, Qian, & Zhou, 2018).
4. Problems with Very large datasets
The size of SQLite database is restricted (140 terabytes) and even it can hold the big
databanks, SQLite stocks all records in a one disk file and multiple filesystems bound the
extreme size of files to somewhat fewer. we expecting records of this greatness, we need to
reflect prefer a client/server database that ranges its contented through numerous disk files,
and possibly through numerous sizes. If our data will cultivate to a dimension that we are not
comfortable or not able to fit into a one disk file, then we must choose a clarification which is
different to SQLite (Kreibich, 2010).
5. Problem with High Concurrency
SQLite cares limitless quantity of concurrent read only thread, it only permit single writer
thread at any specified time. For numerous conditions, it’s not problematic. writer thread line
up. Every request effort speedily and changes on, and no lock persists for extra than a
insufficient dozen milliseconds. But there are approximately applications that need additional
concurrency, and these individuals applications may require a dissimilar solution because
SQLite is not compatible with large volume of writers. If numerous processes require writing
the database at the identical prompt (they not line up and takings chances) at that point it is
greatest way to choose the other engine database which maintenances ability, continually for
example a client/server. SQLite simply maintaining single writers, However in several cases,
a writer operation simply takings smallest unit of time and so numerous writer just takings
opportunities. SQLite tackle multiple writers concurrencies several developer doubtful.
However, client/server architecture, since they procedure at finger to organise contact, can
typically maintain multiple writes concurrency than SQLite (Nell, Fawcett, Hoos, & Leyton-
Brown, 2011).
6. Security issues
9 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Vulnerability in security is the vastly common in the SQLite database engine it keeps many
of the personal computer and the mobile applications at risk. Exposed by Tencent's Blade
safety squad, the susceptibility permits an invader to run hateful code on the casualty's
computer, and in fewer unsafe circumstances, escape program memory or cause program
smashes. Because SQLite is embedded in multiple apps, the vulnerability impacts a wide
range of software, from internet of things (IoT) devices to the desktop software, and from
web browsers, Android and iOS apps also. The compressed and competent environment of
SQLite has headed it to convert very public in mobile development. The library of the SQLite
can comprehend almost every regular SQL commands, with a few exceptions. It also has ties
with general programming languages and is encompassed by avoidance on maximum
smartphones. With a small impression with the server-less databases, clear source code, and
cross-platform ability, all also various advantages of SQLite, But also have disadvantages of
SQLite. In the SQLite database the data is kept as a particular file which can be situated
anyplace in the directory order and may be any reprobate method can open the data file and
can overwrite it. And we can see there is no way to prevent our file from this type of activity,
so security need to be achieved at file level. Extra safety concern is the journaling. When
fluctuations are complete, the SQLite database preserves distinct “journal” or “WAL” files to
assist roll backs. These files are usually transitory and get erased when the operation commits
or rolls back. Though, there are 3 situations that can inhibit with journal removal.
1. If a smash happens in the middle of operation, the -journal or -wal file is kept to disk till
the next use.
2. Application Makers have the choice to set journaling mode to PERSIST (which avoids
the journal from presence erased).
3. Makers also have the choice to put SQLite into limited locking mode (often complete for
act). With this choice, the rollback journal might be condensed or have its header zeroed
(dependent on which variety we are consuming) but the journal itself is not erased till SQLite
exoduses the limited lock mode.
These circumstances were extant severe safety fears for a database management delicate or
complex data ideally; it is potential to turn off journaling at the foundation level. Though, it
is not suggested, because if journal files are lost when the application smashes, the
organisation data in the database will likely be corrupted (Bhosale et al.,2015).
10 | P a g e

Paraphrase This Document

Need a fresh take? Get an instant paraphrase of this document with our AI Paraphraser
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
7. Failure to sync
Now direction toward assurance the records of database remain continuously reliable,
SQLite sporadically request operational system to flush all awaiting write to insistent
storing at that time delay. It consummate by the fsync() system under the unix
and under the window it is FlushFileBuffers() . if there is single apprehensive with the
nuclear and reliable write and they eager to sacrifice vigorous write, the sync process
does not require waiting till the contented is totally stored on persistent media. In its
place, the sync methods can be believed of as an I/O obstacle. As stretched as all writes
that happen earlier the sync are finished previously any write that occurs after the sync,
no database exploitation will happen. If sync is working as an I/O blockade and not as
a correct sync, then a control disaster or system smash may reason of multiple earlier
committed transactions to roll back (in violation of the "durable" property of "ACID")
but the database will at smallest endure to be reliable, and that is what maximum
people care almost (Dar, and J, 2016).
I. Disk drives that do not honour sync requests
Regrettably, the maximum of the consumer like bulk storing devices untruth about the
syncing. Disk drives tale that contented is securely on determined media as quickly as
it spreads the trajectory buffer and earlier essentially being written to oxide. This
creates the disk drives perform to function quicker (which is extremely significant to
the producer so that they can display good standard statistics in professional
magazines). And in equality, the propaganda usually effect no damage, as long as there
is no control damage or solid rearrange prior to the track buffer fundamentally being
written to oxide. But if a power loss or hard reset does occur, and if that consequences
in contented that was written after a sync reaching oxide while contented transcribed
earlier the sync is still in a track buffer, then database exploitation can happen.
The SQLite must accept as true at all the operating system and hardware say it about
the position of sync requirements. There is no approach for SQLite to notice that
whichever is dishonest and that writes might be occurring out-of-order. However,
SQLite in WAL mode is far more forbearing of out-of-order writes than in the
11 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
defaulting rollback journal modes. In WAL mode, the only time that a failed sync
operation can cause database corruption is during a checkpoint operation. A sync let-
down during a COMMIT might outcome in damage of toughness but not in a
fraudulent database file. Hereafter, one line of protection in contradiction of database
exploitation due to unsuccessful sync processes is to use SQLite in WAL mode and to
barrier as infrequently as conceivable (Shi, Ji, & Li, 2018).
8. Non-power safe flash memory controllers
The SQLite database will may be corrupt if we try to modify the content of the file
because it is chance of failure of hard disk or flash memory. There will be chance to
flip a bit of the middle of sector so that it is getting fail.
If power is disturbed when we are writing into the database there can be cause of
random filesystem damage. It can obvious, for example: when unsystematic
modification happening at the mid of a file and the same time if we want to open the
file at the power loss that is very difficult to open. There is probability of damage of the
database even though we are not using at the time of load setting (Nakamura, Nagata,
Nomura, & Yamaguchi, 2014).
9. Memory corruption
SQLite is a C-library which will work on the similar address space whatever the web
application or system application that it serves. That means heap corruption; lost
cursors, buffer overruns or other malfunctions in the application can corrupt interior
SQLite data structure and eventually the outcome in a bad database file. This type of
issues is on top priority even though before database corruption. The memory issue will
be most serious when we are using the memory-mapped I/O. The application’s address
space which is mapped by database file then lost pointer may harm to the database file
(Szekeres, 2017).
10.Different problems with operating system
As we know that operating systems is a most important role to run any
application. The operating system is showing performance issues in the
application and sometime it is an error in the running application. Due to
12 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
operating system compatibility with SQLite, there are many issue of database
corruption (Chen, Han, & Wang, 2010).
I. Linux Threads
There are some versions of Linux used the LinuxThreads library. SQLite
recognized that LinuxThreads were being used at runtime and took appropriate
action to work around the non-standard behavior of LinuxThreads. Now a day’s
new linux is coming with correct nptl implementation of pthread. We can say
that new linux implementation is good for SQLite database. There is very less
possibility of SQLite database failure. It is getting fail or we can say corrupt
when we are using SQLite into the multi-threaded application (Yuan, Guo, Chen,
& Mei, 2018).
II. Failures of mmap() on QNX
The mmap() function maps a region within the object and returns the
location. The SQLite uses this function in unix operating system to create
shared memory region for transactions. If there is large transactions, in this case
the mmap() function is called multiple times. When it is calling many times there
is possibility of database file to be corrupt easily (Oh, Kim, Lee, & Moon, 2015).
III. Corruption File system
As we know that SQLite database is using regular file system to store the data.
There is any breakdown will impact the database or we can called it information.
With the old operating system there is more chances of database corruption
whereas very less chance of corruption with the modern operating systems.
Because modern operating systems are more reliable in comparison to old
operating systems. In other way we can say now there is less possibility of
SQLite error with the modern operating system (Amalfitano, 2015).
11. Bugs in SQLite
13 | P a g e

Secure Best Marks with AI Grader

Need help grading? Try our AI Grader for instant feedback on your assignments.
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
SQLite is a database which comes with library and also come with some of
operating system. But we know there is no software which is totally faultless.
There are the possibilities to be yet a few additional bugs which are remaining
not disclose. SQLite is a light weight databased and also open source so that it
easy available to the developer as well as organisation even though it is coming
with android and iOS versions (Bhosale, Patil, & Patil, 2015).
Please find the list of issues which is encounter while using SQLite:
I. Cloud candidate
SQLite is a server less so that running the server in the cloud is
totally nonsense. Suppose if we try to use SQLite into the cloud in this
case we need to wrap SQLite into the web services. This is extra burden to
developer to use SQLite into the cloud. Second, SQLite is not really multi-
user and cannot do simultaneous concurrent writes. If we need to
write the data concurrently we will have some delays into it, that’s
why SQLite is not a good candidate to use in cloud computing (Arrieta-
Camacho, & Senent, 2014).
II. Unsupported features
List of features are not supported by SQLite:
a. Views are read only in this database
b. FOR EACH STATEMENT triggers.
c. Right Outer Join
d. Full Outer Join
e. DROP COLUMN and ALTER COLUMN
f. ADD CONSTRAINT
These are the limitation of SQLite in order to development of application and database
management. All the above features are important to get data based on the
requirements (Allen, & Owens, 2010).
14 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
III. Client/Server Applications
If we have many client to send sql query to the same database over network, then
we need to use client/server database as SQLite is not handle this situation.
SQLite can work in this situation but the latency will be too high and
performance will not be great.
SQLite can work as database backend for a website but if the website require
more than one server to handle all the client request in this case SQLite is not an
optimal option to use it (Zamfir, & Candea, 2010).
IV. Version issue
As we know that SQLite is a light weight database, it is frequently used by small
application or we can say that standalone application. If we created first time
database using one version and again we write with other SQLite version. If we
again write some of data using old version in this case database file will be
corrupted. In other words we can say that it is not supported backward
compatibility (Jin, Song, Shi, Scherpelz & Lu, 2012).
V. Issue with big data
If our data is growing continuously in this case we can’t fit into a single disk file. We
need to think about other database as SQLite doesn’t support more than one disk file. As
we know that SQLite supports databases up to 140 terabytes in size. We can’t use more
than 14o terabytes data into SQLite so that this is limitation with the SQLite, if we have
more data then we need to consider a centralized client/server database (Sridhar, &
Dharmaji, 2013).
12. File overwriting problem
This is a major concern with SQLite database as we know that this is based on file
system. If users doing continuous close and open a file it causes overwrite issues and
in this case SQLite database become corrupt. SQLite database only support one writer
at a time per database. If user is moving a file from one place to another place, in this
case SQLite is unable to find the file. Similar issue can happen if any user is delete
any file so that same file is unable to find by any other users. In order to get the file
available we need to run database recovery. If we are running backup file at the
backend there is possibility of incomplete transaction. There could be chance of
15 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
mismatch of transaction as it store the old state and new state of any transaction. In
this way we can lose our important transaction (Son, Lee, Kim, Yoo & Lee, 2015).
Conclusion
SQLite is a very simple, lightweight, high-performance, relational database that is widely
used in software designs. But todays is the technology era and approx. everyone uses the
website for their daily uses, so we website which can handle millions of user at a time, and
the website perform well in any difficult condition, the web based application provide the
customer security, data safety, minimise the time of operation perform, less error provide, can
store the millions of user data in an organised way.
And if we use the SQLite a server less database which work on network file system for web
based application it does not suite our requirement because it is not capable for handling the
multiple (millions) of user at a time, in terms of security it is also not recommended to use,
storage capacity is also not good like the other relational database management system.
Today’s we all faces the security and usability concern in any web based database and for
overall SQLite is not fitted properly. So it is recommended that if we use small sized web
based database we will use the SQLite, but if we need large volume of web based database
for our organisation we must go with other database(relational database management system
for example: MYSQL, SQL SERVER etc.) instead of SQLite
References:
Ahmed, R. (2015). SQL-The Shortest Route For Beginners: A fast and easy track for
beginners that covers Oracle, MySQL, Microsoft SQL Server, Microsoft Access,
IBM... SQLite, and MariaDB SQL implementations. CreateSpace Independent
Publishing Platform.
Allen, G., & Owens, M. (2010). Introducing SQLite. In The Definitive Guide to SQLite (pp.
1-16). Apress.
Alvaro, F.(2016). Easy SQL Programming & Database Management For Beginners.
Your Step-By-Step Guide To Learning The SQL Database.
Amalfitano, D., et al.(2015). MobiGUITAR: Automated model-based testing of mobile
apps. IEEE Software. 32(5): p. 53-59.
Arpaci-Dusseau, R. H. (2014). All file systems are not created equal: On the
16 | P a g e

Paraphrase This Document

Need a fresh take? Get an instant paraphrase of this document with our AI Paraphraser
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
complexity of crafting crash-consistent applications. In 11th {USENIX}
Symposium on Operating Systems Design and Implementation ({OSDI}
14) (pp. 433-448).
Arrieta-Camacho, J. J., & Senent, J. S. (2014). Cloud Computing Techniques for Space
Mission Design. In SpaceOps 2014 Conference (p. 1628).
Ashenfelter, J. P. (1999). Choosing a database for your web site. Wiley.
Bhosale, S. T., Patil, T., & Patil, P. (2015). SQLite: Light Database System. International
Journal of Computer Science and Mobile Computing, 882-885.
Bhosale et al (2015). International Journal of Computer Science and Mobile Computing,
Vol.4 Issue.4, pg. 882-885.
Chen, D., Han, X., & Wang, W. (2010). Use of sqlite on embedded system. In 2010
International Conference on Intelligent Computing and Cognitive Informatics (pp.
210-213). IEEE.
Cheung, S. O., Cheung, K. K., & Suen, H. C. (2004). CSHM: Web-based safety and health
monitoring system for construction management. Journal of Safety
Research, 35(2), 159-170.
Dar, S.A. and J. Iqra (2016). Synchronization of Data Between SQLite (Local Database) and
SQL Server (Remote Database). IUP Journal of Computer Sciences,. 10(4): p. 7.
Ganai, M. K. (2012, September). Dynamic livelock analysis of multi-threaded programs.
In International Conference on Runtime Verification (pp. 3-18). Springer, Berlin,
Heidelberg.
Gilbert, A. (2007). Light-weight hierarchical clustering middleware for public-resource
computing (Doctoral dissertation, Oklahoma State University).
Florescu, D., & Kossmann, D. (2009). Rethinking cost and performance of database
systems. ACM Sigmod Record, 38(1), 43-48.
Haldar, S. (2007). Inside sqlite. " O'Reilly Media, Inc.".
Horton, J.( 2015). Android Programming for Beginners. Packt Publishing Ltd.
Huang, J., Guo, J., Zhang, Z., Qian, W., & Zhou, A. (2018). Efficient Auto-Increment Keys
Generation for Distributed Log-Structured Storage Systems. In International
Conference on Web Information Systems Engineering (pp. 225-239). Springer,
Cham.
17 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Hyojun Kim, Nitin Agrawal and Cristian Ungureanu (2012). “Revisiting Storage for
Smartphones”, in ACM Transactions on Storage (Transactions on Storage) ,
Volume 8 Issue 4, November 2012, Article No. 14
Jackson, W.( 2017). Android apps for absolute beginners: covering Android 7. Apress.
Jin, G., Song, L., Shi, X., Scherpelz, J., & Lu, S. (2012). Understanding and detecting real-
world performance bugs. ACM SIGPLAN Notices, 47(6), 77-88.
Kavadas, S., Damalas, D., Georgakarakos, S., Maravelias, C., Tserpes, G., Papaconstantinou,
C., & Bazigos, G. (2013). IMAS-Fish: Integrated MAnagement System to support
the sustainability of Greek Fisheries resources. A multidisciplinary web-based
database management system: implementation, capabilities, utilization and future
prospects for fisheries stakeholde. Mediterranean Marine Science, 14(1), 109-118.
Kreibich, J. (2010). Using SQLite. " O'Reilly Media, Inc.".
Long, S. (2011). Database syncrhonization between devices: A new synchronization protocol
for SQLite databases.
Min, C., Kang, W. H., Kim, T., Lee, S. W., & Eom, Y. I. (2015). Lightweight application-
level crash consistency on transactional flash storage. In 2015 {USENIX} Annual
Technical Conference ({USENIX}{ATC} 15) (pp. 221-234).
Mitrovic, A., Suraweera, P., Martin, B., & Weerasinghe, A. (2004). DB-suite: Experiences
with three intelligent, web-based database tutors. Journal of Interactive Learning
Research, 15(4), 409-432.
Nakamura, Y., Nagata, K., Nomura, S., & Yamaguchi, S. (2014). I/O scheduling in Android
devices with flash storage. In Proceedings of the 8th International Conference on
Ubiquitous Information Management and Communication (p. 83). ACM.
Nell, C., Fawcett, C., Hoos, H. H., & Leyton-Brown, K. (2011). HAL: A framework for the
automated analysis and design of high-performance algorithms. In International
Conference on Learning and Intelligent Optimization (pp. 600-615). Springer,
Berlin, Heidelberg.
Nield, T.(2016). Getting Started with SQL: A Hands-on Approach for Beginners. " O'Reilly
Media, Inc.".
Nwachukwu, D. I. E. (2012). LIGHTWEIGHT DATABASE SYSTEM (LWDBS): AN
OVERVIEW.
Oh, G., Kim, S., Lee, S. W., & Moon, B. (2015). SQLite optimization with phase change
memory for mobile applications. Proceedings of the VLDB Endowment, 8(12),
1454-1465.
18 | P a g e
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Owens, M. (2006). The definitive guide to SQLite. Apress.
Pereira, M. T. (2009). Forensic analysis of the Firefox 3 Internet history and recovery of
deleted SQLite records. Digital Investigation, 5(3-4), 93-103.
Pillai, T. S., Chidambaram, V., Alagappan, R., Al-Kiswany, S., Arpaci-Dusseau, A. C., &
Leschke, T. R., & Nicholas, C. (2013). Change-link 2.0: A digital forensic tool for
visualizing changes to shadow volume data. In Proceedings of the Tenth Workshop
on Visualization for Cyber Security (pp. 17-24). ACM.
Pokorny, J. (2013). NoSQL databases: a step to database scalability in web
environment. International Journal of Web Information Systems, 9(1), 69-82.
Shi, H., Ji, X., & Li, H. (2018). Application of SQLite Database in Dispatch and Substation
Integrated System. In 2018 2nd International Conference on Electrical
Engineering and Automation (ICEEA 2018). Atlantis Press.
Son, M., Lee, S., Kim, K., Yoo, S., & Lee, S. (2015). A small non-volatile write buffer to
reduce storage writes in smartphones. In Proceedings of the 2015 Design,
Automation & Test in Europe Conference & Exhibition (pp. 713-718). EDA
Consortium.
Sridhar, P., & Dharmaji, N. (2013). A comparative study on how big data is scaling business
intelligence and analytics. Int. J. Enhanced Res. Sci. Technol. Eng, 2(8), 87-96.
Stallings, W., Brown, L., Bauer, M. D., & Bhattacharjee, A. K. (2012). Computer security:
principles and practice (pp. 978-0). Upper Saddle River (NJ: Pearson Education.
Sugiharto, H. (2010). Current and Future Mobile Platforms. SNET Master Project.
Szekeres, L. (2017). Memory corruption mitigation via hardening and testing (Doctoral
dissertation, Ph. D. Dissertation. Stony Brook University).
Ungaro, A., Pech, N., Martin, J. F., Mccairns, R. S., Mevy, J. P., Chappaz, R., & Gilles, A.
(2017). Challenges and advances for transcriptome assembly in non-model
species. PloS one, 12(9), e0185020.
Yuan, P., Guo, Y., Chen, X., & Mei, H. (2018). Device-specific Linux kernel optimization
for android smartphones. In 2018 6th IEEE International Conference on Mobile
Cloud Computing, Services, and Engineering (MobileCloud) (pp. 65-72). IEEE.
Zamfir, C., & Candea, G. (2010). Low-overhead bug fingerprinting for fast debugging.
In International Conference on Runtime Verification (pp. 460-468). Springer,
Berlin, Heidelberg.
Zein, S., N. Salleh, and J. Grundy(2015). Mobile application testing in industrial contexts: an
exploratory multiple case-study. in International Conference on Intelligent
Software Methodologies, Tools, and Techniques. Springer.
19 | P a g e

Secure Best Marks with AI Grader

Need help grading? Try our AI Grader for instant feedback on your assignments.
Document Page
Current issues with SQLite: WEB BASED DATABASE CHALLENGES
Zein, S., N. Salleh, and J. Grundy,( 2016). A systematic mapping study of mobile application
testing techniques. Journal of Systems and Software,. 117: p. 334-356.
Zein, S., N. Salleh, and J. Grundy.(2017). Static analysis of android apps for lifecycle
conformance. in Information Technology (ICIT), 8th International Conference on.
2017. IEEE.
20 | P a g e
1 out of 20
[object Object]

Your All-in-One AI-Powered Toolkit for Academic Success.

Available 24*7 on WhatsApp / Email

[object Object]