The article investigates the Alibaba Java development guideline that forbids joining more than three tables by designing MySQL and Oracle experiments, generating massive test data, measuring query performance, analyzing index usage, and concluding why the rule exists and when it can be relaxed.
The article explains how incorrectly placed double‑quotation marks in MySQL UPDATE statements change the intended string assignment into a boolean comparison that evaluates to 0, leading to all affected rows being updated with zero values, and shows how to detect and avoid this pitfall.
This article presents a detailed performance benchmark of MariaDB and MySQL, covering single‑row and batch inserts, as well as various query scenarios with and without indexes, and concludes that MariaDB generally outperforms MySQL while using more memory.
This extensive article introduces Hive as a Hadoop‑based data warehouse, explains its architecture, core concepts, DDL/DML syntax, functions, performance‑optimization techniques, data‑skew handling, and provides a collection of common interview questions for Hive practitioners.
The article explains why Java 8 Stream API is still valuable despite SQL offering similar functions, detailing Stream creation, terminal and intermediate operations, collectors, matching, and practical scenarios where Streams simplify data processing across microservices.
This article explains how to resolve incompatibility between SyBase's default datetime export format and MySQL's datetime format by using the convert() function to reformat dates and str_replace() to adjust delimiters, then exporting the data via bcp for seamless import.
This article explains how MySQL 8.0's WITH clause can be combined with INSERT, UPDATE, DELETE, recursive common table expressions, multiple CTEs and derived tables to generate data, create date sequences, and simplify everyday SQL programming with practical code examples.
This article explains how to enable and configure MySQL's Federated storage engine to access remote tables without data synchronization, covering engine architecture, supported features, environment setup, server configuration, table creation, data manipulation, and binlog verification, along with practical code examples.
This article explains the special nature of NULL in relational databases, demonstrates the correct use of IS NULL versus = NULL, explores three-valued logic, and clarifies how NULL interacts with NOT, NOT IN, and empty strings across different database systems.
This article explains how LEFT JOIN works in SQL, illustrates why duplicate rows can appear when joining tables, and provides practical techniques such as DISTINCT, GROUP BY, MAX, and IN subqueries to ensure a one‑to‑one result set while also covering RIGHT JOIN, INNER JOIN, update and delete operations, and the concept of Cartesian products.
This article explains the MySQL password expiration mechanism, introduces the relevant columns in the mysql.user table, demonstrates how to set passwords to never expire, expire after a specific interval, or expire immediately, and shows how to configure the global default_password_lifetime variable.
This article explains why MySQL deadlocks occur in a test module, details table and row lock mechanisms, reproduces the deadlock scenario with two sessions, analyzes lock logs, and provides a solution by adding a composite index to prevent the conflict.
This article explains why using SELECT * in MySQL queries hurts performance, explores the underlying reasons such as extra data transfer, I/O overhead, and loss of covering index optimization, and provides practical guidance on index usage and best practices.
The article details how Alibaba’s Data Bank leverages AnalyticDB’s cold‑hot tiered storage, high‑throughput real‑time writes, and low‑latency OLAP capabilities to handle petabyte‑scale consumer data, support flexible AIPL analysis, crowd profiling, and rapid audience selection while cutting costs and ensuring elasticity during peak events.
This article explains what NoSQL means, contrasts it with SQL and relational databases, walks through schema design, primary keys, indexing, and then demonstrates how to implement a lightweight key‑value NoSQL store in pure Python with full command parsing and handling.
This article explains the hidden costs of using SELECT * in MySQL—such as extra data transfer, increased I/O, and loss of covering‑index optimization—while detailing how proper column selection and composite indexes can dramatically boost query efficiency.
The article explains why adding conditions after a LEFT JOIN using AND does not filter rows from the left table, contrasts ON and WHERE clauses, and demonstrates the behavior with SQL examples and step‑by‑step illustrations of intermediate result tables.
This article explains MySQL full-text (inverted) indexes, their underlying auxiliary tables, buffer pool configuration, document ID handling, and the special transaction semantics required for inserting and querying indexed data, providing practical SQL examples and performance considerations.
This article analyzes six MySQL pagination techniques, presents benchmark results showing how query time grows with offset, and offers practical index‑based optimizations—including covering indexes, subqueries, and composite index design—to make LIMIT pagination fast even on very large tables.
This article explains MySQL index fundamentals, covering primary and unique indexes, best practices for choosing indexed columns, handling functions and large fields, avoiding excessive or frequently updated indexes, and enumerates typical scenarios where indexes become ineffective.
This article explains how LEFT JOIN works in SQL, clarifying that the ON clause only matches rows without filtering left‑table records while the WHERE clause filters the joined result, and demonstrates the differences with multiple code examples and table illustrations.
This article explains how MySQL's sys.diagnostics stored procedure collects performance metrics, the information it reports, required permissions, command examples, configurable parameters, and how to generate and interpret diagnostic reports for effective database analysis.
This article examines why full-table scans become slow on large MySQL tables, demonstrates various pagination techniques—including simple LIMIT, sub‑query, ID‑range, and IN‑clause methods—provides benchmark results for different record counts and offsets, and offers practical tips to dramatically speed up paginated queries.
This tutorial demonstrates how to use Spark SQL to create, insert, update, delete, merge, and drop Apache Hudi tables, covering environment setup, Spark‑SQL launch, configuration, and a series of SQL commands with example outputs.
This article explains MySQL’s internal architecture—including server and storage engine layers—and walks through each stage of query processing from connection and authentication, through query cache, parsing, optimization, and execution, illustrated with a concrete SELECT example.
This article explains how MySQL maintains primary and composite (non‑primary) indexes using B+ trees, outlines the essential equality‑matching, left‑most‑prefix, and range‑scan principles, and shows how to combine them with ORDER BY, LIMIT, and GROUP BY for optimal query performance.
This article presents Kuaishou's comprehensive engineering practices for improving Flink's stability, task startup latency, and SQL performance, including high‑availability Kafka connectors, fault‑recovery mechanisms, I/O reductions, asynchronous job upgrades, aggregation optimizations, and future resource‑utilization plans.
This article explains the three‑layer architecture of MySQL, how an execution plan is generated and interpreted, and provides a detailed walkthrough of the columns displayed by the EXPLAIN statement to help developers optimize their SQL queries.
The article explains why massive MySQL tables need periodic cleanup, compares risky drop/truncate approaches, and provides a step‑by‑step guide to safely delete historical data in batches using pt‑archiver with proper parameters, session handling, and post‑deletion maintenance.
This article explains why MySQL subqueries often cause performance bottlenecks, describes the underlying execution mechanism, and presents practical optimization strategies—including semi‑join, materialization, and EXISTS—plus a real‑world case study showing how to rewrite a slow query into a fast join.
This comprehensive guide covers fundamental SQL clauses, aggregate functions, joins, set operators, Oracle-specific objects, essential DML/DDL commands, and a curated collection of 50 interview questions with detailed query examples and performance tips for database professionals.
This article outlines ten practical strategies—including avoiding chat tools for SQL, compressing statements, using SELECT COUNT, adding LIMIT, updating audit fields, logical deletion, table backups, temporary tables, fully qualified names, and careful column changes—to help developers, testers, and DBAs prevent costly database errors in production environments.
This article explains MySQL's lock granularity (table, row, page), the different lock modes such as next‑key, gap and record locks, illustrates common deadlock scenarios with detailed SQL examples, and discusses InnoDB's deadlock prevention strategies and best‑practice solutions.
This guide provides a thorough walkthrough of SQL fundamentals, including SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT, aggregate functions, joins, set operations, Oracle-specific objects, DDL/DML commands, and a collection of classic interview questions with complete query examples and performance tips.
This article walks through downloading the required Flink and Hudi components, building Hudi for Scala 2.12, and demonstrates step‑by‑step how to create, populate, query, and update Hudi tables in both batch and streaming modes using Flink SQL, complete with code snippets and result screenshots.
This article compiles 50 practical SQL performance optimization techniques—from indexing strategies and query rewriting to avoiding full table scans, using temporary tables, proper data types, and efficient backup methods—helping developers write faster, more scalable database queries.
This article explains why adding extra conditions after the ON clause in a LEFT JOIN does not reduce the number of rows from the left table, clarifies the difference between ON and WHERE filters, and demonstrates the behavior with practical SQL examples and diagrams.
This article demonstrates how to configure Flink 1.12 to read data from HBase, covering the required environment components, HBase table creation, Maven dependencies, Java POJO and Flink‑SQL code, and showing the query results with and without printing the TableResult.
The article explains that inserting ‘WHERE 1=1’ in dynamically built SQL statements prevents syntax errors when appending additional conditions, illustrates its use with Java string concatenation examples, discusses performance considerations, and shows how to copy tables or duplicate structures using this technique.
This article explains the differences between DROP, DELETE, and TRUNCATE, recommends appropriate MySQL data types for monetary values, compares MyISAM and InnoDB storage engines, outlines transaction ACID properties, describes views, stored procedures versus triggers, indexes, UNION vs UNION ALL, and lists the main SQL language categories.
This article explains the storage units of InnoDB, calculates how many rows a B+‑tree leaf page can hold, derives the total record capacity for trees of different heights, and shows how to determine the actual B+‑tree height in a MySQL table using page metadata.
This comprehensive guide explores MySQL’s origins, key characteristics, logical architecture, storage engines, transaction handling, concurrency control, and detailed indexing strategies, offering practical insights and best‑practice recommendations for developers and database administrators seeking to master MySQL performance and reliability.
This article explains the core principles of MySQL indexes, covering their essence, various types such as hash, binary, B‑tree and B+‑tree, the structure of primary key directories and index pages, clustered versus non‑clustered indexes, and the back‑table lookup process.
This guide explains how to identify MySQL max‑connection errors, check the current limit, and increase it using configuration files, global variables, source‑code changes, or mysqld_safe adjustments, with detailed commands and code examples for various MySQL versions.
This comprehensive guide explains what MyBatis is, its advantages and drawbacks, usage scenarios, differences from Hibernate, key syntax like #{ } vs ${ }, mapping techniques, pagination, caching, lazy loading, batch operations, dynamic SQL, and how to configure mappers and plugins in Java projects.
This comprehensive guide explains how to migrate Oracle databases to MySQL by detailing type differences, migration steps, performance tuning, and validation techniques, while highlighting common pitfalls such as data‑type mismatches, character‑set issues, LOB handling, and transaction isolation nuances.
This article explains common reasons why Oracle indexes may be ignored—such as column comparisons, NULL values, NOT conditions, wildcard placement, functions, data type conversions, arithmetic predicates, and special index types—and provides practical SQL examples and tips to ensure indexes are utilized for better query performance.
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 provides a comprehensive overview of MyBatis, covering its definition as a semi‑ORM persistence framework, core architecture, key components, advantages and drawbacks, practical usage patterns, and a collection of common interview questions with detailed answers for Java developers.
The article explains why both equality and inequality comparisons with a NULL value in MySQL return no rows, illustrating common interview misconceptions and emphasizing the need to grasp NULL semantics for reliable database programming.
This article demystifies MySQL’s query execution by exploring its logical architecture, client‑server protocol, query cache, parsing, optimization, and execution engine, then offers practical indexing and performance‑tuning techniques—including B‑Tree fundamentals, covering indexes, and pagination tricks—to help developers write faster, more efficient SQL.
This article introduces the Laravel‑query‑builder package, explaining how to replace complex IF‑ELSE query logic with a configuration‑driven approach, and provides installation steps, usage examples, and code snippets for building flexible SQL queries in Laravel applications.
This tutorial demonstrates how to use MySQL Shell's three components—MySQL, MySQL X, and SHELL—to connect to a sample WORLD database, perform CRUD operations, execute transactions, and run advanced queries with code examples for each component.
This article explains the multiple reasons why SELECT * slows down MySQL queries—including extra parsing, unnecessary data transfer, increased I/O, and loss of covering index optimization—while also covering index fundamentals, composite indexes, and practical tips for writing efficient SELECT statements.
This guide explains how to use ProxySQL's stats_mysql_query_digest to detect rarely accessed MySQL tables, export table lists, script the retrieval of last access times, and safely rename or drop unused tables after verification, helping reduce storage waste and metadata overhead.
This article provides a thorough overview of relational database fundamentals, covering basic concepts, SQL syntax, DML and DDL commands, functions, joins, unions, grouping, ordering, transactions, permission management, stored procedures, cursors, and triggers, complete with illustrative code examples.
This article explains the purpose and proper use of the SQL HAVING clause, demonstrates how it works with GROUP BY to filter aggregated groups, shows examples for finding groups with specific counts, missing IDs, mode, median, and non‑NULL values, and clarifies best practices for query performance and semantics.
This tutorial explains how to select a technical architecture, design a three‑layer data warehouse (ODS, CDM, ADS), model tables and dimensions, choose storage strategies, handle slowly changing dimensions, synchronize data with DataWorks, and implement dimensional modeling and fact tables using Alibaba MaxCompute for big‑data analytics.
This article explains how JDBC evolves into MyBatis, detailing the seven-step JDBC process, the motivations for encapsulating JDBC, the design of MyBatis components such as SqlSession, Executor, and StatementHandler, and various optimization strategies including connection pooling, SQL management, dynamic parameters, and caching.
This article presents nine practical MyBatis techniques—including pagination, preset column selection, one‑to‑many and one‑to‑one associations, foreach‑in queries, dynamic where clauses, choose/otherwise logic, hidden _parameter usage, and dynamic set updates—illustrated with SpringBoot and MySQL code examples.
This article outlines ten practical techniques—from avoiding chat tools for SQL transmission to using soft deletes, backup tables, and proper field management—to help developers, testers, and DBAs safeguard production databases against accidental data loss and costly errors.
This article explains various situations—such as column-to-column comparisons, NULL values, NOT conditions, wildcard LIKE patterns, functions on indexed columns, low‑cardinality leading columns in composite indexes, implicit datatype conversions, arithmetic predicates, virtual and invisible indexes—that can cause an otherwise usable index to be bypassed by the optimizer, leading to full‑table scans.
This guide introduces DBeaver, a free open‑source database management tool, explains how to download and install it on various operating systems, shows how to create and test database connections (e.g., PostgreSQL), manage JDBC drivers, and generate ER diagrams from existing schemas.
This article explains MySQL index types—including ordinary, unique, primary, composite, and full‑text indexes—their creation syntax, optimal usage scenarios, situations where indexes should be avoided, cases that render indexes ineffective, and how to interpret EXPLAIN output types for query performance analysis.
This article evaluates several Java persistence solutions—JOOQ, MyBatis, Hibernate, JPA, and JDBC Template—by examining SQL encapsulation, DSL adaptability, cross‑database portability, security, and the specific drawbacks of JOOQ, ultimately concluding that JDBC Template best fits the project’s needs.
This article explains how DBAs can use PostgreSQL's extensive logging parameters and log_line_prefix settings to locate and reconstruct every SQL statement within a transaction, illustrated with practical cases, command‑line examples, and step‑by‑step log‑analysis techniques for lock troubleshooting.
This article outlines ten practical MySQL development guidelines—from always using InnoDB and simple data types to avoiding SELECT *, ENUM, and low‑cardinality indexes, while emphasizing proper naming, charset choices, NOT NULL constraints, and continuous SQL monitoring with Percona Toolkit.
This article outlines ten practical MySQL development guidelines—from using InnoDB tables and simple data types to avoiding SELECT * and unnecessary ENUMs—helping DBAs and developers collaborate more efficiently and write cleaner, faster SQL.
This article explains how to build a distributed read‑write lock using MySQL tables and transactions, covering the business scenario, lock table design, detailed SQL procedures for write and read operations, logging, dead‑lock handling, and a cleanup job.
The article explains how to perform efficient user retention, funnel, and session analysis on large ClickHouse datasets by replacing costly multi‑table joins with bitmap compression, the built‑in retention function, windowFunnel, and high‑order array functions, providing practical SQL examples and performance insights.
This article explains what correlated subqueries are, why they challenge database engines, and how they can be transformed into ordinary SQL using decorrelation, push‑down rules, result reuse, and window‑function tricks, illustrated with TPCH examples and code snippets.
This guide explains how to verify that MySQL binlog is enabled, locate binlog files, use the mysqlbinlog utility to extract change logs for specific time ranges or tables, and apply the extracted SQL to recover or roll back erroneous data modifications.
This article introduces ClickHouse, explains its column‑oriented architecture versus row‑oriented databases, details a MySQL‑to‑ClickHouse migration, shows a performance benchmark that reduces query time from minutes to seconds, and shares practical deployment tips and common pitfalls.
This article explains how to use MySQL's LOAD DATA command to import CSV and fixed‑length text files, covering basic parameters, sample data and table structures, four practical scenarios, and best‑practice tips for handling mismatched schemas and large files.
This article explains the difference between MySQL multi-value indexes and composite indexes, demonstrates how to create and query multi-value indexes using JSON columns, and shows performance benefits and practical scenarios when dealing with tables that have a large number of columns.
The article explains why developers insert the clause "WHERE 1=1" in dynamically generated SQL statements, shows example Java code, discusses how it prevents syntax errors when concatenating AND conditions, and offers advice on adding selective filters and indexes to avoid full table scans.
The article explains how Apache Kylin and MLSQL complement each other, detailing Kylin's OLAP strengths, MLSQL's data‑processing and AI capabilities, and demonstrates a low‑code integration that enables users to perform ETL directly within Kylin’s interface while outlining future deep‑link scenarios.
This article explains SparkSQL's overall workflow, introduces the basic elements of joins, and details the physical execution processes for various join types—including sort‑merge, broadcast, and hash joins—along with their implementation conditions and optimization considerations.
This article provides a comprehensive overview of MyBatis, a semi‑ORM Java framework, covering its core concepts, benefits, drawbacks, appropriate use cases, differences from Hibernate, parameter handling, dynamic SQL, caching, lazy loading, mapper binding, plugin development, and various configuration techniques.
This article explains why a MySQL join query may ignore an index because of implicit character‑set conversion, demonstrates how to diagnose the issue with EXPLAIN and schema queries, and provides a fix by converting the column to UTF8 in the SQL statement.
Learn ten practical strategies—from avoiding chat tools for SQL to using logical deletes, backups, and proper field management—to dramatically reduce the risk of costly database mishaps in production environments, ensuring safer data operations and easier recovery.
This comprehensive guide explains what MyBatis is, its advantages and drawbacks, suitable use cases, differences from Hibernate, parameter handling, dynamic SQL, pagination, caching, lazy loading, and how to use mapper interfaces, XML mappings, and plugins with clear code examples.
The article shows how to generate a Node.js V8 heap snapshot with v8.getHeapSnapshot, explains the JSON‑like .heapsnapshot structure of nodes, edges, and strings, and demonstrates using the heapquery tool to import the data into SQLite for SQL queries that locate and trace memory‑leaking objects such as a HugeObj instance.
This article explains the upsert‑kafka connector in Flink, its configuration parameters, step‑by‑step usage with SQL examples, and demonstrates a complete pipeline that reads Kafka streams, aggregates page view metrics, and synchronizes the results to TiDB in real time.
A developer discovers that massive OFFSET values in MySQL pagination cause full‑table scans and severe latency, then reproduces the issue with simulated data, benchmarks the slowdown, and presents three practical solutions—including index‑covering subqueries, cursor‑based pagination, and offset limits—to restore query performance.
This article explains what a prefix (partial) index is in MySQL, why it can reduce index size and improve query speed, outlines suitable scenarios and limitations, and demonstrates performance differences through a series of tests with varying prefix lengths on a large test table.
This article explains how to use PostgreSQL's row-level and column-level security features to restrict user access to specific rows and columns, providing step‑by‑step examples, code snippets, and discussion of policies, BYPASSRLS, and performance considerations.
This article explains the different SQL join types—including equi‑join, natural join, inner join, self‑join, outer joins, and cross join—detailing their syntax, behavior, and practical usage with example queries and optimization tips.
This article explains how to manage database write and query operations in PHP using PDO, covering initialization, error handling, and providing complete code examples for inserting and selecting records.
This article explains how MySQL versions prior to 8.0 automatically sorted GROUP BY results, why the optimizer added this hidden ordering, how the behavior was removed in MySQL 8.0, and what developers must watch for when migrating, illustrated with concrete SQL examples and EXPLAIN output.
This article explains how Flink SQL can be used to construct a unified stream‑batch ETL pipeline for data warehouses and data lakes, covering data integration, CDC support, streaming writes to Hive and Iceberg, and various join techniques such as regular, interval, and temporal joins.
This article reviews the history of MySQL, introduces MariaDB as its open‑source fork, and presents a series of benchmark tests—including single‑row inserts, batch inserts, and various query scenarios—showing that MariaDB generally outperforms MySQL in speed while using more memory.
An in-depth case study describes how to dramatically improve the performance of a massive MES reporting query—reducing execution from over half an hour to seconds—by analyzing inefficient SQL, adding proper indexes, avoiding full table scans, redesigning with stored procedures, temporary tables, and selective use of NOLOCK.
During a holiday‑time alert, a seemingly harmless pair of UPDATE statements on the same InnoDB table caused a deadlock, and the article walks through log analysis, reproduction steps, lock mechanics, and practical ways to avoid such deadlocks in MySQL.
This article explains in detail how ClickHouse processes a user‑submitted SQL query, covering the server’s request handling, parsing, query rewrite, optimization, interpreter execution, and result transmission, while illustrating key source code snippets and architectural components.
This article provides a comprehensive overview of ClickHouse's table engines, explaining the purpose and characteristics of each engine series—including Log, Integration, Special, and the various MergeTree families—while offering detailed SQL examples and guidance on when to use each engine for different data workloads.
This article compiles fifty‑two actionable tips for improving SQL query performance, covering index creation, query rewriting, use of temporary tables, proper data types, server configuration, and best practices for MySQL and other relational databases.
This article translates and expands on a HikariCP wiki post, explaining why smaller database connection pools often yield better performance, presenting benchmark videos and data, describing the underlying CPU, disk, and network constraints, and offering a simple formula to calculate an optimal pool size for typical server configurations.
This article explains how incorrectly placed double‑quotation marks in MySQL UPDATE and SELECT statements cause implicit type conversion, turning intended string assignments into zero values and making WHERE clauses always true, leading to massive data corruption and unexpected query results.
This article examines several MySQL pagination techniques—including basic LIMIT, subquery‑based, ID‑range, and temporary‑table methods—provides detailed performance measurements on a multi‑million‑row table, and offers practical recommendations for fast and scalable data retrieval.
