This article provides a comprehensive guide to JDBC, covering its definition, core interfaces (Connection, Statement, ResultSet), the advantages of PreparedStatement, the need for connection pools, pagination techniques for Oracle and MySQL, and practical usage of DBUtils with full code examples.
This article reviews the Text-to-SQL semantic parsing task, covering its motivation, dataset landscape, major model architectures such as pointer networks, sequence‑to‑set, and grammar‑based approaches, evaluation metrics, the newly built DuSQL dataset and DuParser system, real‑world deployments, and remaining research challenges.
This article examines recent database deletion incidents and offers DBA‑level guidance on strengthening processes, technical safeguards, and security policies, covering backup‑restore design, performance optimization, high‑availability strategies, and self‑service automation to avoid future data loss.
This article explains which components consume CPU on a MySQL server, analyzes the impact of user‑space processing and IO wait, and provides practical strategies—such as optimizing indexes, reducing unnecessary calculations, and improving IO handling—to lower CPU usage and improve overall database performance.
This article provides a comprehensive guide to Laravel's query builder, covering basic CRUD commands, selective column retrieval, complex where clauses, joins, aggregations, raw expressions, inserts, updates, deletions, unions, locking mechanisms, and query caching with clear code examples for each feature.
This tutorial walks you through installing MySQL 5.7 on two CentOS 7.6 machines, configuring the master and slave my.cnf files, setting up replication users, starting the services, and verifying synchronization with detailed commands and troubleshooting tips.
This article explains Redis's two persistence mechanisms—RDB snapshot files and AOF append‑only logs—including their operation, configuration commands, advantages, disadvantages, recovery procedures, and performance recommendations for choosing between them.
Redis 6.0.0 GA, the biggest release to date, adds a redesigned client cache, ACL improvements, faster RDB loading, a new STRALGO command, and optional multithreaded I/O that can double network performance, while urging careful testing before production use.
Redis 6.0.0 stable release brings major updates such as redesigned client‑side caching, immediate RDB deletion for replication, enhanced ACL logging, faster PSYNC2 partial resynchronization, decimal timeout support, up to 30% faster RDB loading, and a new STRALGO command for string algorithms.
This guide compiles essential MySQL security steps, master‑slave replication principles, backup scripts, Linux boot overview, common port services, virus mitigation, monitoring tools, nginx optimization, InnoDB lock troubleshooting, replication lag reduction, high‑availability components, data migration utilities, and automation configuration management techniques for operations engineers.
This comprehensive MySQL FAQ covers its definition, implementation language, key features, differences from SQL, storage engines, data types, triggers, security tips, performance considerations, and practical queries such as retrieving the N‑th highest salary, providing a solid reference for developers and DBAs.
This article provides concise answers to common MySQL questions covering default ports, regular expression usage, index limits, query examples for retrieving rows, date functions, savepoints, ENUM types, storage engines, connection functions, ACLs, and other essential database concepts.
The article outlines the historical evolution of IT architecture—from early single‑machine deployments through hot‑standby and multi‑node active clusters to modern distributed systems—explaining the motivations, trade‑offs, and key technologies that drive each generation and offering guidance on selecting the right architecture for business needs.
MySQL 8.0.20 introduces a range of enhancements including new SHOW_ROUTINE privilege, hash join improvements, index‑level optimizer hints, performance schema refinements, SQL syntax changes, InnoDB doublewrite buffer relocation, binary log transaction compression, X Plugin and protocol upgrades, and additional replication options.
This article explains the fundamentals of SQL parsing, describing the roles of lexical analysis, syntax analysis, and visitors, and demonstrates the process with a concrete SELECT statement example, while also mentioning popular parsing libraries such as Druid and ANTLR.
This article explains what Redis Cluster is, how it partitions data and provides redundancy, and walks through installing Redis on CentOS, configuring multiple nodes, and creating a functional cluster using both manual commands and the built‑in cluster management tool.
This article explains database bottlenecks caused by IO and CPU limits, introduces horizontal and vertical sharding for databases and tables, compares popular sharding tools, discusses challenges such as distributed transactions, cross‑node joins, pagination and global ID generation, and offers guidance on when and how to apply sharding in real‑world systems.
This comprehensive guide walks you through essential Oracle database administration tasks—including starting and stopping the database, managing listeners, creating and altering tablespaces, handling users and privileges, controlling transactions, building indexes, defining views and materialized views, working with sequences, synonyms, and partitioned tables—complete with commands, examples, and best‑practice tips.
A concise Laravel DB cheat sheet that covers basic usage, query builder methods, joins, aggregates, inserts, updates, deletes, unions, and pessimistic locking with clear code examples for each operation.
This article explains the principles, evolution, modern structures, compaction strategies, optimization techniques such as Bloom filters and partitioning, and concurrency and recovery mechanisms of Log-Structured Merge (LSM) trees, which are widely used in contemporary NoSQL storage systems.
This article explains the differences between Laravel's ORM and DB query builder, outlines their advantages and appropriate use cases, and provides step‑by‑step code examples for defining models, retrieving, creating, and deleting records, as well as handling transactions.
Learn how to dramatically boost Redis speed by shortening key/value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, pipelines, avoiding mass expirations, optimizing clients, limiting memory, running on physical servers, tweaking persistence, disabling THP, and adopting distributed architectures.
This article explains why a MyBatis query may return zero rows even though the identical SQL run directly in the database returns data, and shows how correcting line‑break placement in the XML mapper resolves the inconsistency.
This article chronicles Tencent's database team overcoming three major challenges—supporting WeChat red packets, stabilizing Honor of Kings gameplay, and ensuring Tencent Video streaming—by developing CKV, CDB, TcaplusDB, and DBBrain technologies that balance performance, cost, and reliability.
This cheat sheet provides a concise yet comprehensive guide to Laravel's Eloquent Model, covering definition, artisan commands, common CRUD methods, soft‑deletes, relationship types, model events, and configuration tips, all illustrated with ready‑to‑copy code examples.
This article explains how Redis implements two persistence mechanisms—RDB snapshots and AOF logs—covering their triggers, execution flows, advantages, drawbacks, differences, restart recovery procedures, and practical ways to mitigate performance overhead caused by fork operations.
This roundup covers Tencent Cloud's first domestic serverless PostgreSQL database, GitHub's free core features for all users, the nginx 1.17.10 release with a new auth_delay directive, a COBOL programmer's urgent call, and upcoming Linux dual‑boot on iPhone, among other tech headlines.
Meituan’s DBA team discovered that Intel Skylake CPUs dramatically increased PAUSE‑instruction latency, causing MySQL’s ut_delay spin‑wait loops to consume most CPU cycles and reduce write throughput, and they restored performance by back‑porting MySQL 8.0’s spin_wait_pause_multiplier patch to 5.7, upgrading to CentOS 7, and moving to Cascadelake hardware.
This tutorial explains how to configure Laravel's Eloquent ORM, create and customize model classes, manage table names, primary keys, timestamps, perform queries, insert, update, delete records, handle soft deletes, apply global and local scopes, and work with model events and observers, all with practical PHP code examples.
This article explains how to size and tune Druid's connection pool for high‑traffic Java applications, covering pool‑size formulas, timeout settings, keep‑alive behavior, essential XML properties, and version recommendations to prevent misleading SQL latency and improve overall database stability.
This tutorial demonstrates how to set up a Spring Cloud project, add MyBatis-Plus dependencies, configure the data source and MyBatis-Plus settings, and perform full CRUD operations with Java code examples, providing a practical guide for backend developers.
This guide explains how Laravel’s query builder offers a secure, fluent interface for constructing and executing database queries, covering result retrieval, filtering, aggregation, joins, unions, inserts, updates, deletes, and advanced features like raw expressions, JSON handling, and pessimistic locking.
This guide explains how to configure Laravel's supported databases, set up SQLite, implement read/write connection splitting, use multiple connections, execute raw SQL queries, listen to query events, and manage transactions—including deadlock handling and manual control—complete with code examples.
This guide explains how to use Laravel seeders to generate test data, covering creation of seeder classes via Artisan, inserting records manually or with model factories, calling additional seeders, and the commands needed to run or refresh database seeding.
Tencent Cloud is hosting a three‑month online technical salon, featuring dozens of senior database experts who will nightly dissect the architecture, implementation and best practices of domestic databases such as TDSQL, TBase and CynosDB/CDB, with April’s TBase sessions open for reservation via QR code and offering live‑stream giveaways.
This tutorial walks through creating the five microservice databases for the PassJava platform using PowerDesigner, detailing each service’s schema, showing screenshots, and providing the GitHub repository where the SQL files can be accessed.
This article shows backend developers how to use PyCharm Professional’s integrated Database tool and HTTP Client to connect to MySQL, perform visual CRUD operations, and test RESTful APIs directly within the IDE, eliminating the need for separate tools like Navicat and Postman.
This tutorial walks you through creating a web‑based employee management system that demonstrates MongoDB CRUD operations using Python, Flask, and Pipenv, covering project setup, environment configuration, code implementation for querying, adding, updating, and soft‑deleting records, and how to run the application.
This tutorial walks through pulling the Redis Docker image, creating configuration files, running the container, connecting with redis-cli, testing commands, enabling persistence, and installing a visual management tool, providing complete step‑by‑step instructions for Docker‑based Redis deployment.
This tutorial explains how to download the MySQL Docker image, create and run a MySQL container with volume mappings and environment variables, verify the container, connect to the database via Workbench, and access the container’s shell and host files.
This comprehensive guide introduces NoSQL concepts, classifies non‑relational databases, explains why MongoDB is suited for loosely structured data, walks through Windows and Linux installations, demonstrates using Robo 3T, and covers all CRUD operations, queries, updates, deletions, and data de‑duplication with practical code examples.
This tutorial explains how to install PyMongo, connect to local or remote MongoDB instances, choose databases and collections, and perform all common CRUD operations—including inserts, queries, updates, deletions, and special cases—using Python code examples and practical tips.
Senior DBA Yang Jianrong shares how standardized processes, robust security, and modern optimization—such as partitioning, middleware, and NoSQL—combined with high‑availability designs and self‑service tools like automated slow‑log analysis can streamline large‑scale MySQL operations, migrations, and continuous DBA learning.
The TVP Technical Closed‑door Conference gathered 44 experts across eight sessions to examine post‑pandemic technology trends—including blockchain as institutional infrastructure, cloud‑native databases and serverless computing, industrial internet transformation, data‑driven online education, federated learning for privacy‑preserving AI, and the shift toward resource‑focused technical entrepreneurship.
This article demonstrates how to build a reusable Python class with pyodbc to connect to Microsoft SQL Server, import CSV files, create tables, and perform common operations such as push, union, and drop, providing complete code examples and explanations for each step.
This article provides an in‑depth analysis of MySQL's filesort mechanism, explaining the original and modified algorithms, how sort and addon fields are calculated, memory allocation strategies, the role of temporary files, and practical tips to reduce excessive disk usage during sorting operations.
This article presents thirty actionable SQL performance recommendations—including selecting specific columns, using LIMIT, avoiding OR and functions in WHERE clauses, proper indexing, batch inserts, and query planning—each illustrated with clear examples and explanations to help developers write faster, more efficient queries.
This guide walks you through setting up a six-node Redis cluster using Docker Compose, configuring the necessary redis.conf settings, deploying the containers, initializing the cluster, and then integrating the cluster into a SpringBoot application via appropriate application.yml configurations and connection commands.
This article explains the purpose of Spring's @Transactional annotation, details its configurable attributes, and enumerates six typical scenarios—such as non‑public methods, wrong propagation settings, self‑invocation, and unsupported database engines—that cause the annotation to become ineffective, providing code examples and solutions.
This article examines various MySQL pagination methods—including simple LIMIT, offset impact, sub‑query, ID‑range, and temporary‑table strategies—provides detailed performance measurements on a table with over five million rows, and offers practical recommendations for speeding up large‑scale data retrieval.
This article presents ten practical Redis best‑practice guidelines—from avoiding the costly KEYS * command and leveraging SCAN, to using INFO for command statistics, employing hashes, setting expirations, selecting eviction policies, handling errors, scaling with clusters, understanding threading limits, and configuring Sentinel for high availability.
A detailed reference covering MySQL service management, connection commands, database and table operations, data types, indexes, joins, subqueries, transactions, backup, user privileges, and common SQL functions, complete with practical code examples.
This article explains several typical pitfalls that cause Spring's @Transactional annotation to be ineffective, such as unsupported database engines, unmanaged service beans, internal method calls, non‑public methods, default rollback rules, and missing transaction manager configuration, and provides practical solutions for each case.
This article explains the distinctions between UNION and UNION ALL, TRUNCATE and DELETE, TIMESTAMP and DATETIME, introduces composite and covering indexes, describes InnoDB versus MyISAM storage, the left‑most prefix rule, monotonic primary keys, int display length, SHOW INDEX fields, handling LIKE patterns, and efficient pagination techniques.
This article explains MySQL storage engines, compares MyISAM and InnoDB, introduces the main index types—B‑Tree, Hash, Full‑text, R‑Tree—details the structures and characteristics of B‑Tree, B‑Tree and B+Tree, and outlines key principles for creating effective indexes.
This article explains the seven common SQL JOIN variations—including INNER, LEFT, RIGHT, FULL OUTER, and their exclusive forms—illustrated with diagrams and complete SELECT statements, helping readers understand how each join type combines rows from two tables based on key relationships.
This article presents ten practical Redis best‑practice tips—including avoiding KEYS *, using SCAN, monitoring command stats, leveraging hashes, setting expirations, choosing eviction policies, handling errors, scaling with clusters, understanding threading, and configuring Sentinel—for improved performance, stability, and high availability.
This article explains core MySQL concepts, comparing UNION and UNION ALL, TRUNCATE versus DELETE, TIMESTAMP and DATETIME, composite and covering indexes, the left‑most prefix rule, clustered vs non‑clustered indexes, prefix indexes, InnoDB vs MyISAM storage, monotonic primary keys, column length display, SHOW INDEX fields, LIKE pattern pitfalls, and efficient pagination techniques.
This guide explains essential MySQL concepts such as the distinction between UNION and UNION ALL, TRUNCATE versus DELETE, TIMESTAMP versus DATETIME, the purpose and benefits of composite indexes, index storage engines, prefix indexes, covering indexes, the left‑most prefix rule, and efficient pagination techniques.
Idempotency ensures that repeated execution of an operation yields the same result as a single execution, and this article explains its importance in backend systems, outlines concepts, and presents practical techniques such as unique indexes, token mechanisms, pessimistic and optimistic locks, distributed locks, and API design for reliable, duplicate‑free processing.
This article presents ten practical Redis best‑practice recommendations—from avoiding the costly KEYS * command and using SCAN, to leveraging hashes, setting key expirations, choosing appropriate eviction policies, handling errors, scaling with clusters, and ensuring high availability—helping developers optimize performance and reliability.
This guide explains how to define Django model classes, map them to database tables, and use the makemigrations and migrate commands to generate and apply migrations, illustrated with Users and Files examples and the resulting SQL schema.
The article documents a puzzling MySQL 5.7.25 bug where RAND() in a derived table is unexpectedly re‑evaluated in the outer query, explains the step‑by‑step reproduction, analyses the cause, and provides official work‑arounds for both MySQL 5.7 and 8.0.
This article provides a comprehensive overview of MySQL InnoDB's internal architecture, covering its memory and disk structures, buffer pool, change buffer, adaptive hash index, log buffer, various tablespace types, page layout, undo and redo logs, double‑write buffer, transaction isolation levels, and how the engine satisfies ACID properties.
This tutorial explains how to integrate JDBC into a Spring Boot project, covering Maven dependencies, MySQL driver setup, application.yml datasource configuration, Spring Boot's auto‑configuration mechanism, JdbcTemplate usage, Swagger documentation, CRUD endpoint implementation, and solutions to typical connection errors.
This article provides a comprehensive guide to Python's file handling capabilities, covering built‑in functions, the csv module, numpy's load and save methods, pandas' extensive read/write utilities, Excel libraries such as xlrd and openpyxl, and popular database connectors like pymysql and sqlalchemy.
This guide walks through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and application.yml settings, and using EasyCode to automatically generate CRUD code for the defined tables.
This guide explains MySQL fundamentals—including what a database is, transaction concepts and ACID properties, isolation levels and their effects, index structures and the left‑most prefix rule, storage engine differences, lock algorithms, and practical techniques for optimizing large tables such as partitioning and sharding.
This article walks through building a MySQL user table, defining the corresponding Java entity and MyBatis‑Plus mapper, and demonstrates basic query operations such as selectList, selectById, selectBatchIds, and selectByMap with full code examples and the generated SQL statements.
This tutorial demonstrates how to create a User table, define the corresponding entity and mapper classes, and perform basic MyBatis-Plus queries such as selectList, selectById, selectBatchIds, and selectByMap, including the required SQL scripts and Java code examples.
This tutorial walks you through installing the PyMySQL library, configuring connection parameters, establishing a Python‑MySQL link, and performing full CRUD operations—including creating tables, inserting, querying, updating, and deleting records—while also covering cursor methods and pandas integration.
This step‑by‑step guide explains how to add the PostgreSQL Yum repository, install PostgreSQL 12 client and server packages, initialize and start the database service, set the admin password, optionally enable remote access, and install the pgAdmin 4 web interface on CentOS 7 or 8 systems.
This article explains why a Redis instance creates 16 default databases, how they function as simple namespaces rather than separate applications, how to configure their number, and why Redis clusters support only a single database.
This whimsical yet technically detailed article explores how a mythic Hell‑DBMS could be architected, covering unique identifiers, massive concurrent writes, batch processing, NoSQL tree‑structured storage, disaster recovery, and a real‑world demo project that brings the underworld’s life‑and‑death ledger to life.
The article explains how to overcome performance degradation in DBLE‑based pagination by using a constant LIMIT clause, filtering with id‑based conditions, and adhering to sharding‑key constraints, while outlining practical steps, limitations, and best‑practice recommendations for continuous page navigation.
This article explains the concept of Hash Join in MySQL 8.0, compares it with Nested Loop joins, shows how to enable or force it with server variables or hints, and presents performance benchmarks that demonstrate its speed advantages on large datasets.
MySQL 8.0.19 introduces InnoDB ReplicaSet, Router enhancements, numerous SQL syntax additions, optimizer improvements, new Information Schema role views, security features, replication options, X Protocol compression, and a range of deprecations and bug fixes, providing a comprehensive update for database administrators and developers.
This article explains the principles of MySQL master‑slave replication and provides a detailed, step‑by‑step tutorial for configuring a master and a slave instance in a Docker environment, including configuration files, Docker commands, replication setup, testing, and troubleshooting.
This article demystifies MyBatis transaction handling by clarifying the true JDBC transaction methods, explaining Spring's propagation concepts, detailing the MyBatis Transaction and TransactionFactory interfaces, showcasing code examples, and exploring special cases such as auto‑commit nuances and connection‑pool interactions.
This article explains how MySQL X API (available since MySQL 5.7) can replace NoSQL databases by enabling the X protocol, showing configuration steps, equivalent insert examples, and detailed CRUD, indexing, and transaction operations with code snippets.
This guide explains the new Redis 6.0 cluster proxy feature, its purpose, and provides step‑by‑step instructions for installing, starting, and connecting to the proxy, including required GCC upgrades and example commands for a smooth setup.
Learn step-by-step how to query MySQL 5.7 and 8.0 to list the top three orders by amount for each month, using variables and ranking functions, with full SQL examples, explanations, and visual results.
This guide explains how Laravel handles session storage across HTTP requests, covering configuration files, built‑in drivers such as file, cookie, database, Memcached and Redis, custom driver creation, and common session operations like retrieving, storing, flashing, and regenerating IDs, with code examples throughout.
A chaotic incident‑response story shows how a DBA and SA scramble through VPN glitches, broken jump servers, log hunting, ad‑hoc config tweaks, unexpected bugs, security scans, and frantic firefighting to finally restore a production system, highlighting the messy reality of modern operations.
This guide walks you through setting up LDAP authentication for Zabbix, covering Active Directory OU creation, Zabbix server LDAP module verification, configuration parameters, user provisioning, fallback to internal authentication, and the related database tables and SQL commands.
The article explains why idempotent operations are essential in high‑traffic systems, defines idempotency, and presents a comprehensive set of techniques—including unique indexes, token validation, pessimistic and optimistic locking, distributed locks, select‑plus‑insert patterns, state‑machine design, and API safeguards—to guarantee consistent outcomes even under repeated requests.
This tutorial walks through creating an end‑to‑end Zhihu hot‑list project that scrapes the billboard page, stores the data with Flask‑SQLAlchemy, schedules periodic updates, exposes RESTful APIs, and finally displays the results in a uni‑app mini‑program with interactive charts.
This article explains ClickHouse's deployment architecture, read‑write separation, shard expansion steps, write‑batch strategies, a three‑layer monitoring model, and its practical application in Tencent's game analytics platform, offering concrete guidance for building a stable, high‑throughput analytics service.
In his CNBPS 2019 keynote, MongoDB architect Song Zhiqi discusses how the shift to cloud‑native architectures has amplified data volume and variety, outlines the key challenges such as rapid rollout, downtime, and unstructured data, and explains how MongoDB’s flexible, high‑availability document model addresses these issues while supporting modern micro‑service and Kubernetes ecosystems.
This article explains the fundamentals of LEFT JOIN in SQL, illustrates one‑to‑one, one‑to‑many, and many‑to‑many scenarios, compares ON versus WHERE conditions, and provides concrete MySQL and Hive examples with code snippets and visual diagrams to avoid common mistakes.
This article tackles the challenge of ordering hard‑coded role levels in a MySQL table by presenting ten distinct SQL solutions—including adding a helper column, using FIELD, FIND_IN_SET, CASE, subqueries, UNION, hash‑based formulas, and custom arithmetic—so that a "vice‑manager" (level 2) can be ranked above a "manager" (level 3).
In this interview, Ming Xiyuan, Technical Solutions Director at iKangSheng, shares practical guidance on selecting and deploying high‑availability MySQL solutions for the financial sector, covering planning pitfalls, hardware considerations, key configuration parameters, and the company’s product roadmap.
This article explains how to set Redis's maximum memory usage via configuration files or commands, describes the built‑in eviction strategies including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, volatile‑ttl, and shows how to query and change these policies, while also covering LRU fundamentals, a Java LRU cache example, Redis's approximate LRU implementation, its 3.0 optimizations, and the newer LFU eviction algorithm.
The article explains why using the KEYS command on large Redis datasets can cause service blockage and demonstrates how the SCAN command with MATCH and COUNT options provides a non‑blocking, incremental way to list keys, including syntax and practical examples.
This article explains the importance of idempotent operations in backend systems, defines the concept, and presents practical techniques such as unique indexes, token mechanisms, pessimistic and optimistic locking, distributed locks, state‑machine design, and API patterns, complete with code snippets and diagrams.
This guide walks you through setting up the open‑source MySQL Monitor tool, covering environment preparation, installation, database schema import, host configuration, alert channel setup (email and WeChat), cron scheduling, and accessing the monitoring pages, all with a clean Chinese interface.
This article provides a comprehensive overview of Redis, explaining its core data structures, caching use cases, persistence mechanisms, high‑availability features like Sentinel and replication, clustering for horizontal scaling, and client‑side capabilities such as transactions, Lua scripting, pipelining, and distributed locks.
This comprehensive guide covers fundamental SQL Server operations such as creating databases, tables, indexes, and views, advanced techniques like set operators, subqueries, and linked servers, plus step‑by‑step instructions for replication, backup, compression, and automated synchronization using stored procedures and SQL Agent jobs.
This guide walks through installing Zabbix 4.4.0 on CentOS 7, configuring PostgreSQL, adding the TimescaleDB time‑series extension, setting up the Zabbix database, and tuning Linux, Nginx, and PHP so the monitoring platform runs smoothly with high‑performance time‑series storage.
This article explains how to use MySQL's EXPLAIN command, describes each column in its output—including id, select_type, table, type, possible_keys, key, key_len, ref, rows, filtered, and Extra—provides syntax examples, discusses join type rankings, and outlines the command's limitations for query performance analysis.
