This article introduces SQLite, explains why it is the most widely deployed lightweight SQL engine, outlines its common use cases in mobile, desktop and IoT devices, compares it with MySQL and PostgreSQL, and provides step‑by‑step installation instructions.
SQLite, a lightweight serverless relational database written in C, powers billions of devices and is used for mobile app storage, embedded systems, offline desktop applications, small‑to‑medium data analysis, and browser‑based acceleration via WebAssembly, supporting languages such as C, C++, Java, Python, and Swift.
This article presents ten practical Python scripts—including data analysis with Pandas, web scraping with BeautifulSoup, file renaming, image resizing, PDF generation, email sending, data backup, password generation, a simple HTTP server, and SQLite backup/restore—to help automate common programming tasks.
This article explains why SQLite, the lightweight embedded relational database, is the most widely deployed database in the world, detailing its origins, core features, and diverse usage scenarios across mobile, embedded, desktop, data analysis, and web acceleration contexts.
This guide introduces SQLite‑Web, a Python‑based web interface for SQLite, explains how to build and run its Docker image, details the command‑line options for configuring ports, hosts, authentication, and other features, and shows how to manage, query, and export SQLite databases through the browser.
Despite powering billions of devices, critical components like the TZ time‑zone database and SQLite are maintained by just a handful of volunteers, and the article reveals how this fragile reliance could cause massive disruptions if those small teams were to disappear.
Learn how to create a simple, high‑performance Rust microservice using Actix‑web, Serde, and SQLite, covering environment setup, project structure, core code for CRUD operations, and testing commands, while highlighting Rust’s memory safety, speed, and low runtime overhead.
SQLite 3.46.0 introduces extensive PRAGMA enhancements, new date‑time modifiers, support for underscore digits in numeric literals, a json_pretty() function, significant query planner optimizations, improved JSON handling, and the ability to use large hexadecimal literals as column defaults, all while maintaining its public‑domain, self‑contained nature.
This guide introduces Atuin, an SQLite‑backed shell history enhancer, explains its key features, shows how to install it on Linux, configure syncing, and demonstrates powerful commands for searching, statistics, and importing existing history.
Despite powering the modern internet, essential software like the TZ time zone database and SQLite are maintained by just a handful of volunteers, highlighting the fragility of critical infrastructure and the insufficient financial support from large corporations.
WCDB 2 introduces multi-language support (C++, Java, Kotlin), a rewritten SQL builder, fast backup and recovery with sub‑second times, incremental WAL‑based backup, automatic data migration, Zstandard compression, on‑the‑fly column addition, and performance enhancements such as an FTS5 optimizer and interruptible transactions, delivering a robust high‑performance mobile database solution.
The Cloud Music team integrated a lightweight on‑device full‑text engine using SQLite FTS5 with a simple tokenizer, replaced JavaScript matching with SQLite’s bm25(), parallelized queries, and cut search latency by 75%, boosting CTR 13% and average playback by 17 seconds while preserving user privacy.
This guide explains why an in‑memory SQLite database is ideal for PHP unit testing, outlines its key benefits such as isolation, speed, and resource efficiency, and provides step‑by‑step code examples for setup, data handling, cleanup, exception handling, schema verification, data providers, and transaction testing.
This article details the major upgrades of WCDB, including expanded language support, a redesigned Winq SQL builder, robust data backup and repair mechanisms, seamless data migration, on‑the‑fly compression, automatic column addition, and performance optimizations such as interruptible transactions and WAL header improvements.
This tutorial walks you through using PHP's SQLite3 extension to install the driver, connect to a file‑based SQLite database, create tables, and execute full CRUD operations—including inserting, querying, updating, and deleting records—plus closing the connection and viewing data with an IDE.
This tutorial walks through connecting to an SQLite database with PHP, creating a 'users' table using SQL, and verifying the table’s structure through PRAGMA queries, providing complete code examples for each step to help developers understand SQLite integration in web projects.
This guide walks you through installing the Go SQLite3 driver, opening a database connection, creating tables, inserting records, querying data, and provides a complete runnable example, helping developers integrate lightweight SQLite storage into Go applications efficiently.
This article explores SQLite’s 2018 SQL feature updates—from boolean literals and truth testing to window functions, FILTER clauses, upsert syntax, column renaming, and related API changes—highlighting syntax details, limitations, and practical examples for developers seeking to leverage these modern capabilities in production.
This article reviews SQLite’s 2018 SQL enhancements—including Boolean literals, window functions, the FILTER clause, upsert syntax, and column‑renaming—explaining each feature, showing concrete code examples, comparing behavior with other databases, and noting remaining limitations.
This article traces SQLite’s origins from a 2000 Navy project, explains how its first version wrapped GDBM, details its layered architecture and code flow, and shows how Richard Hipp’s philosophy of building every component himself turned SQLite into the ubiquitous embedded database we see everywhere today.
This article explores why SQLite is the world’s most ubiquitous database, tracing its birth from a Navy project, its early implementation atop GDBM, the layered architecture that processes SQL statements, the transition to a B‑tree engine, and the creator’s philosophy of self‑contained software.
This article explains how front‑end developers can expand into full‑stack development by using Next.js with server‑side rendering, Prisma ORM, and SQLite to create a functional Todo List application, covering installation, database schema, server actions, and client‑side form handling.
esProc SPL, a pure‑Java, lightweight data‑processing engine, offers richer data source support, built‑in flow control, and easier complex calculations compared to SQLite, making it a powerful alternative for small applications that need database‑like capabilities without the overhead of traditional databases.
This article explains how to build a Text‑to‑SQL application using LangChain, OpenAI LLMs, and SQLDatabaseChain, covering the fundamentals of Text2SQL, LangChain components, code examples, and a practical SQLite case that transforms natural‑language questions into executable SQL queries.
SQLite 3.44.0 introduces enhanced aggregate functions with ORDER BY support, new scalar functions like concat(), string_agg(), expanded strftime() format specifiers, additional C APIs, stricter PRAGMA behavior, improved query planner optimizations, runtime detection of long‑double support, and default UTF‑8 handling in the Windows CLI.
This announcement details a book giveaway sponsored by Tsinghua University Press and presents a comprehensive SQL learning curriculum covering SQLite, MySQL, query fundamentals, subqueries, joins, and advanced database features, complete with micro‑lecture videos and hands‑on exercises.
Atuin replaces the traditional shell history with a SQLite‑backed, feature‑rich UI, offering encrypted synchronization across machines, detailed command metadata, and flexible search capabilities, while providing multiple installation methods and shell plugin integrations for zsh, bash, and fish.
This article explains SQLite's Rollback and WAL logging modes, compares their performance and concurrency characteristics, investigates a real‑world problem where duplicate IM message IDs appear after app upgrades, and presents a step‑by‑step solution using UNIQUE constraints and index checks to prevent repeated inserts.
This article provides concise Python code snippets for connecting to and querying a variety of popular databases—including MySQL, PostgreSQL, SQLite, MongoDB, Oracle, SQL Server, Redis, Elasticsearch, Cassandra, Couchbase, Firebase, DynamoDB, Neo4j, and InfluxDB—illustrating the essential steps for each.
This article compares SQLite and MySQL, outlines SQLite’s advantages and disadvantages, describes scenarios where SQLite is appropriate, and provides a step‑by‑step PHP tutorial with complete code for connecting, creating tables, inserting, querying, updating, deleting, and closing an SQLite database.
The article analyzes SQLite's shortcomings in data‑source support, complex calculations, and workflow handling for tiny Java apps, then demonstrates how the open‑source esProc SPL engine offers richer data‑source integration, simpler SQL‑like syntax, powerful calculation capabilities, and built‑in flow control, making it a more suitable lightweight database alternative.
SQLite 3.42.0, the widely used public-domain SQL database engine, introduces features such as FTS5 secure-delete, JSON5 support, new sqlite3_config options, enhanced query planner optimizations, CLI improvements, additional SQL functions, extended PRAGMA integrity_check, subsecond time modifiers, and various bug fixes and performance enhancements.
This article reviews the SQLite SQL enhancements introduced between versions 3.22.0 and 3.26.0, covering boolean literals, window functions, the FILTER clause, upsert syntax, column renaming, and related API changes, while comparing SQLite’s support to other major database systems.
SQLite’s 2018 updates bring powerful new SQL capabilities—including true/false literals, IS TRUE/FALSE predicates, window functions, FILTER clauses, UPSERT syntax, and column‑renaming—demonstrating that this lightweight, serverless database can handle modern workloads while remaining reliable and widely deployable.
This article details the motivation, research, architecture, driver selection, DSL design, Kotlin Symbol Processor code generation, and future roadmap of SQLlin, a lightweight, cross‑platform SQLite framework built with Kotlin Multiplatform for Android and iOS.
This article introduces xlite, a Rust‑based SQLite extension that lets you import Excel files as virtual tables and run full SQL queries for data lookup and analysis, outlining a simple three‑step workflow and noting current read‑only limitations.
This article reviews SQLite's 2018 enhancements, covering Boolean literals, window functions, the FILTER clause, UPSERT syntax, column‑renaming support, and other API changes, while comparing SQLite's capabilities to other major database systems.
SQLite 3.39.3, the latest version of the widely used embedded SQL database engine, introduces RIGHT and FULL OUTER JOIN support, new binary comparison operators IS NOT DISTINCT FROM and IS DISTINCT FROM, additional APIs such as sqlite3_db_name, enhanced file‑name handling, HAVING clause for aggregates, and overall CPU optimizations reducing cycles by about 2.3%.
This article analyzes the performance and storage problems of the Windows version of WeChat, explains why message growth causes slowness, large file size, and corruption risk, and presents a multi‑pronged solution involving sharding, indexing, payload compression, and robustness improvements that halve database size and boost I/O performance by about ten percent.
This article examines SQLite's journal modes, Android's thread and connection‑pool configurations, and demonstrates through source‑code analysis that converting a database from the default rollback‑journal mode to write‑ahead logging (WAL) is safe and improves concurrency performance.
This tutorial walks through building a simple Python web crawler for the QDaily website, covering target analysis, environment setup, SQLite database creation, data extraction with requests and BeautifulSoup, storing articles and comments, performing basic analysis, and visualizing results with a word cloud.
This article reviews SQLite's 2018 enhancements, covering Boolean literals, window functions, the FILTER clause, upsert support, column renaming, and related API changes, while highlighting limitations and compatibility notes compared with other major databases.
The article explains SQLite’s 2018 enhancements—including boolean literals, window functions, FILTER clause, UPSERT syntax, and column‑renaming—detailing how these features work, their syntax, limitations, and providing code examples for developers seeking to use SQLite in production environments.
SQLite, often underestimated, introduced several powerful SQL enhancements in 2018—including boolean literals, window functions, FILTER clauses, UPSERT syntax, and column renaming—bringing its capabilities closer to major RDBMSes while retaining its lightweight, file‑based design.
The article reviews SQLite's 2018 enhancements—including boolean literals, window functions, FILTER clause, UPSERT syntax, and column‑renaming—explaining their syntax, behavior with NULLs, and practical examples, while also noting SQLite's reliability and deployment advantages despite lacking a network layer.
This article reviews the SQLite SQL enhancements introduced between versions 3.22.0 and 3.26.0 in 2018, covering boolean literals, window functions, FILTER clauses, UPSERT syntax, column renaming, and related API changes with code examples and practical notes.
This article reviews the SQLite enhancements introduced between versions 3.22.0 and 3.26.0 in 2018, covering Boolean literals, window functions, the FILTER clause, UPSERT syntax, column renaming, and related API changes, while comparing them to other major database systems.
SQLite, often underestimated, has added powerful SQL capabilities in 2018—including true/false literals, advanced boolean checks, window functions, FILTER clauses, upsert support via INSERT ON CONFLICT, and column renaming—bringing its feature set closer to major databases while retaining its lightweight, file‑based architecture.
The article walks through building a minimal SQLite‑style database in Go, covering memory‑disk page storage, B‑tree indexing, simple SQL parsing for INSERT and SELECT, row serialization, a pager that flushes pages, and a basic REPL, while highlighting current single‑page limits and future extensions.
SQLite version 3.38.0 introduces new JSON operators compatible with MySQL and PostgreSQL, built‑in JSON functions, added unixepoch() and auto/julianday modifiers for date/time, renamed printf() to format(), enhanced virtual table interfaces, CLI columnar output options, and query planner optimizations using Bloom filters and balanced merge trees.
This article details the 2021 overhaul of iOS WeChat's full‑text search, covering engine selection, segment‑merge optimization, a new VerbatimTokenizer, multi‑level separator support, table schema choices, asynchronous index updates, and extensive performance gains across chat, contacts, and favorites.
This article introduces the PrettyTable Python library, explains how to install it, demonstrates creating tables with headers, adding rows and columns, importing data from CSV, databases, or HTML, and shows various output formats and styling options for clear command‑line presentation.
This article details Youku’s practical experience developing HarmonyOS widgets, covering Ability packaging, mixed Android‑HarmonyOS builds, card UI designs, lifecycle callbacks, data fetching via WebView, local caching with SQLite, update strategies, and lessons learned for future mobile development on HarmonyOS.
This tutorial walks through setting up Python 2.7 on Ubuntu, then demonstrates how to install, connect to, and perform CRUD operations with four different databases—SQLite, MySQL, LMDB, and LevelDB—showing complete example scripts and summarizing the key differences between relational and key‑value stores.
This guide walks you through creating a client‑side static Wikipedia by downloading a dump, converting it to a SQLite database compiled to WebAssembly, and building a JavaScript front‑end that can be deployed on any static‑file host.
Discover how althttpd, the minimalist C‑based web server created by SQLite’s author Richard Hipp, powers the high‑traffic SQLite.org site with minimal resources, its simple design philosophy, low‑cost hardware usage, and why it makes an excellent learning project for developers.
A programmer needed to create a billion‑row SQLite test database within a minute, found a naïve Python script unbearably slow, applied batch inserts and SQLite PRAGMA tweaks, then compared CPython, PyPy, and Rust implementations, ultimately achieving sub‑minute runtimes with Rust and highlighting best‑practice optimizations.
This guide demonstrates two methods to reset the Grafana admin password: directly editing the SQLite database file with SQL commands and using the grafana-cli tool, including all required shell commands and screenshots.
This guide explains Go’s built‑in testing framework, assertion libraries, table‑driven and sub‑tests, and demonstrates how to mock functions, structs, interfaces, databases, and Redis using tools such as ngmock, gomock, sqlmock and miniredis, while covering test setup, teardown, coverage handling, and best‑practice insights.
The article recounts how Richard Hipp created SQLite—a tiny, fully embedded 900 KB database written in a single C file—that now powers billions of devices, and how his later Althttpd web server handles hundreds of thousands of requests daily, illustrating his prolific open‑source legacy.
This guide walks you through installing SQLite, using a graphical management tool, understanding its data types and keywords, and performing core database operations such as creating, viewing, exporting, attaching, and detaching databases, all with practical command‑line examples and screenshots.
This article provides a comprehensive, step‑by‑step guide to SQLite, covering table creation, deletion, data manipulation, queries, index management, view creation, trigger usage, and transaction control, complete with code examples and illustrative screenshots for developers of all levels.
This article explains how enterprises can evaluate their needs and compare four popular open‑source relational databases—MySQL, PostgreSQL, MariaDB, and SQLite—covering licensing, performance, language support, strengths, and limitations to guide an informed selection.
When selecting an open‑source database, enterprises must assess their specific data needs, understand licensing differences, and weigh the strengths and weaknesses of popular options such as MySQL, PostgreSQL, MariaDB, and SQLite, as this guide details.
This article walks through using Google’s Room ORM in an Android project to create a SQLite database, define entities and DAOs, set up a singleton database instance, and implement add, query, fuzzy search, and delete operations via a simple UI.
This article explains how iOS obtains the night‑mode launch image by analyzing the naming pattern of cached images, inspecting the SQLite‑based applicationState.db file, extracting the XBApplicationSnapshotManifest entry, and reconstructing the actual image path using system‑level data structures.
This guide demonstrates how to extract a macOS Chrome user's browsing URLs and timestamps from the History SQLite database, save them to a text file, and automatically email the file daily using Python scripts, a shell wrapper, and a crontab scheduled task.
This tutorial walks Python developers through using the built‑in sqlite3 library to create, query, and manage SQLite databases, demonstrates how to connect with SQL clients like DBeaver, and shows seamless integration with Pandas data frames for advanced data handling.
The article presents Sponsor, a lightweight ORM‑style wrapper for Android’s native SQLite that uses runtime annotations and dynamic proxies to generate Retrofit‑like, type‑safe CRUD APIs, automatically handling table creation, upgrades, and threading while keeping performance overhead negligible for SDK developers.
SQLite 3.32.0, the latest release of the world’s most widely used database engine, introduces approximate ANALYZE support, a bytecode virtual table, new SQL functions, expanded parameter limits, numerous CLI enhancements, and behavior changes that align the LIKE operator with PostgreSQL, offering developers richer functionality and improved compatibility.
This guide shows how to generate hourly slow‑query reports from MySQL slow‑log files by using pt‑query‑digest’s timeline feature, filtering with sed, importing the data into SQLite with termsql, and then querying the results to identify hotspot periods and recurring patterns.
This article explains what SQL injection is, demonstrates a SQLite example that injects malicious code to drop a table, and then shows how to prevent such attacks using parameterized queries, input validation, and secure coding practices.
This article explains what SQL injection is, demonstrates a vulnerable SQLite example that drops a table using malicious input, shows why the attack works, and provides practical prevention techniques such as using parameterized queries, input validation, unpredictable table names, and regular backups to secure databases.
This tutorial walks through creating a web‑based server monitoring tool that tracks CPU load and disk usage, using Vue.js with Element UI and Echarts for the frontend and a Python Flask backend with SQLite for data storage and API delivery.
This article explains how to handle high‑concurrency instant‑messaging scenarios by designing message deduplication, optimizing SQLite write performance with batch inserts and WAL mode, improving query speed with indexes and caching, and reducing UI refresh overhead through delayed and scroll‑aware updates.
This guide walks through using Python's requests and BeautifulSoup libraries to simulate Zhihu login, extract user profiles, retrieve answer likers, download avatars, fetch all answers for a question, and store the collected data in a SQLite database.
This article explains how to build a Python‑based Dash web application that parses Chrome's SQLite history file, extracts URLs, visit counts and timestamps, and visualizes the data with Plotly charts, covering project structure, key functions, file handling, and deployment steps.
This article explains how Android applications can create and use SQLite databases—including custom file paths and no‑Context scenarios such as UIAutomator tests—by detailing standard SQLiteOpenHelper usage, source‑code analysis, and three methods for customizing database locations.
This article compares SQLite, MySQL, and PostgreSQL across architecture, features, scalability, use cases, and limitations, helping developers choose the most suitable relational database for their specific application requirements.
This article introduces SQLiteLint, a runtime analysis tool that automatically checks SQLite usage in mobile apps for index problems, redundant indexes, SELECT *, AUTOINCREMENT, missing prepared statements, and without‑rowid opportunities, enabling developers to catch performance issues before release.
This article walks through creating a Python web crawler for Zhihu, covering simulated login, fetching user profiles, extracting answer likers, downloading avatars, gathering all answers for a question, and storing the collected data in a SQLite database.
This article explains how WeChat Android tackles the challenge of Chinese homograph full‑text search by using SQLite FTS5, comparing word‑based and character‑based indexing schemes, introducing a custom tokenizer, and detailing preprocessing and performance results.
An in‑depth look at SQLite’s Write‑Ahead Logging (WAL) mode and the asynchronous checkpoint optimization used in WeChat’s WCDB, covering implementation details, performance gains, A/B test results, and practical code examples for enabling these features on Android.
This guide walks through installing and using four Python‑compatible databases—SQLite, MySQL, LMDB, and LevelDB—covering environment setup, core APIs, common CRUD patterns, and complete runnable examples to help developers choose and operate each storage engine effectively.
This article provides a comprehensive guide to Android's Room persistence library, covering the creation of Entity classes, defining Data Access Objects (DAO), building the RoomDatabase, handling foreign keys, embedded objects, query methods, LiveData and RxJava return types, as well as database migrations and type converters for complex data types.
This article details how to create a simple Chinese pinyin input method using a Hidden Markov Model, training data from Jieba, storing probability matrices in SQLite, and implementing the Viterbi algorithm in Python, complete with code snippets and performance observations.
This article explains the principles of SQLite’s Full‑Text Search extension, details WeChat’s architecture for mobile search, and shares practical performance‑tuning techniques—including custom tokenizers, offset function improvements, and SQL‑level ranking—to achieve sub‑50 ms query times on billions of records.
This article compares FMDB and WCDB, detailing smooth migration steps, benchmark results showing WCDB's superior write and multithreaded performance, reduced code complexity, built‑in encryption, statistics and repair tools, and provides practical guidance for developers considering a database switch.
This article chronicles the development of WCDB, WeChat’s open‑source mobile database, detailing its early challenges, performance bottlenecks, security risks, concurrency improvements, cross‑platform collaboration, and future roadmap for a more reliable and efficient data layer on iOS and Android.
This article examines WCDB’s design principles for efficient, complete, and easy-to-use client-side databases, explains the pitfalls of SQL string concatenation such as code redundancy, debugging difficulty, and injection attacks, and describes how WCDB’s WINQ abstraction and ORM layer safely encapsulate SQLite syntax to enable concise, compile-time-checked queries.
This comprehensive SQLite tutorial walks beginners through what SQLite is, how to install it on Windows and Linux, essential syntax, CRUD operations, database objects, functions, and language-specific programming interfaces, providing step‑by‑step instructions and visual aids for practical mastery.
This article chronicles the development of WCDB, Tencent WeChat's open‑source mobile database, detailing its early platform challenges, performance and security improvements, cross‑platform collaboration, and future plans to enhance usability, speed, and reliability.
WeChat’s WCDB component tackles pervasive SQLite corruption on mobile devices by combining dump‑based, backup, and B‑tree parsing recovery methods, achieving up to 78% success while supporting encrypted databases, large data volumes, and seamless user experience.
This article provides a comprehensive overview of SQLite, covering its file‑based embedded architecture, type affinity, core components, supported data types, essential API functions, transaction management, and techniques for storing and retrieving binary data in embedded applications.
This article introduces WCDB, the official WeChat mobile database component, covering its architecture, ORM macros, WINQ integrated query, multithreaded high‑concurrency support, corruption repair, and advanced usage such as as‑redirection, chainable calls, and custom field binding for iOS/Mac development.
This article walks through building a Python web scraper for Zhihu, covering login simulation, extracting user profiles, answer likers, followers, avatars, and all answers of a question, and storing the collected data in SQLite, while highlighting challenges like captcha and anti‑scraping limits.
Facing a 0.02% SQLite corruption rate that threatened years of chat history, the WeChat mobile team identified three main causes—insufficient space, power loss, and sync failures—and implemented space management, full sync settings, and master‑table backups, halving damage and doubling repair success.
WeChat reduced its SQLite chat‑record corruption rate by over 50% by optimizing storage space, enforcing full file synchronization (including iOS fullfsync), and implementing a dual‑backup strategy for the master table with CRC checks and pre‑allocated space, dramatically improving repair success.
This tutorial demonstrates how to build a single, reusable SQLite library in Free Pascal using CodeTyphon, covering platform‑specific APIs, export conventions for Android, iOS, PC, and detailed compilation and usage examples across Android, iOS, macOS, Linux, and Windows.