This comprehensive guide shares a seasoned DBA's practical advice on environment awareness, hardware considerations, security, routine operations, architecture, and mindset to help database professionals avoid common pitfalls and improve reliability in MySQL production systems.
This article explains how Oracle's parallel processing feature can accelerate data‑intensive queries by configuring session, table, or hint‑based parallelism, shows the degree‑of‑parallelism formula, and presents experimental results that compare execution times under different settings.
Drawing from a year‑and‑a‑half of ops experience, this guide outlines six practical categories—online operation standards, data handling, security, daily monitoring, performance tuning, and mindset—to help engineers avoid costly mistakes and maintain stable, secure systems.
This article explains what an Oracle SQL execution plan is, how statistics guide the optimizer, various ways to retrieve plans, the classification of plan types, and practical tips for spotting and fixing inefficient plans using real‑world examples and code snippets.
This guide walks through practical Linux hardening steps—including minimal installation, SSH port changes, sudo privilege tailoring, extensive kernel sysctl tuning, firewall adjustments, system version hiding, file protection, and package installation strategies—to boost security and performance while keeping the system lean.
This article explains what MySQL's slow query log is, when it is generated, the key configuration parameters, how to interpret its output, useful analysis utilities, and best practices for cleaning and backing up the log files.
The article shares a DBA's real‑world experiences—from a risky MySQL restart that exposed hidden issues, through practical learning advice and MySQL technical nuances, to a detailed Oracle migration case—offering actionable insights for database professionals seeking robust data management and performance optimization.
This article explains how Meituan‑Dianping leverages the open‑source tool Sysbench for repeatable database performance testing, unifies test parameters, optimizes MySQL settings such as slave_parallel_workers, extends functionality via Lua scripts, and reveals the tool’s high‑performance data‑collection techniques.
This article analyzes the limitations of the original TMP monitoring storage architecture, evaluates OpenTSDB's shortcomings at large scale, and details the design, implementation, and performance tuning of a custom HBase-based solution that achieves 3‑5× higher throughput for billions of monitoring data points per day.
This article explains Oracle database performance tuning by introducing the five key performance reports—AWR, ASH, ADDM, AWRDD, and AWRSQRPT—detailing how to obtain them, what metrics to focus on, and how to apply them in real‑world case studies for both simple and complex optimization scenarios.
BeeGFS is a GPL‑licensed parallel file system for Linux that offers scalable storage through a modular architecture of management, metadata, and object storage servers, supports a wide range of hardware and OS platforms, and provides detailed installation, configuration, and performance‑tuning guidance including the BeeOND burst‑buffer extension.
A developer added a seemingly harmless filter to an Oracle SQL statement, causing the optimizer to switch the driving table and join method, which inflated execution time from 2 seconds to 90 seconds, prompting a deep dive into execution plans, indexing, and hint techniques.
This article compiles 38 practical Oracle SQL tuning techniques—from ordering tables and rewriting WHERE clauses to using indexes, avoiding SELECT *, leveraging DECODE, replacing HAVING with WHERE, and preferring TRUNCATE over DELETE—each illustrated with clear examples to help developers write faster, more efficient queries.
When migrating applications from Oracle to MySQL, many teams encounter severe performance problems such as CPU saturation, high logical and physical reads, and slow queries, and this article outlines the root causes—including lack of parallelism, limited join algorithms, IN‑list limits, subquery inefficiencies, missing materialized views, and unsupported function indexes—and provides concrete remediation strategies for each issue.
This article examines common performance and reliability problems encountered in Redis master‑slave deployments—such as AOF and SAVE settings, key count mismatches, client output buffer limits, replication backlog size, and node liveness checks—and provides concrete configuration commands and tuning strategies to improve stability, especially in cloud environments.
This article explains how Oracle's bind variable peeking influences execution plan selection, demonstrates the performance differences between full table scans and index scans with skewed data distributions, and provides practical methods—including 10046 events, v$sql_bind_capture, and AWR views—to capture and analyze bind variable values for better SQL tuning.
This article explains what constitutes a database performance problem, outlines essential metrics such as response time, throughput, baseline and bottleneck identification, and presents practical tuning methods—including workload reduction, resource configuration, and optimization balance—to help engineers systematically improve database efficiency.
This article walks through a detailed Hadoop performance tuning case using the TPCx-HS benchmark, explaining the bottlenecks in TeraGen and TeraSort, the optimization strategies applied, hardware considerations, and the resulting improvements in CPU and network utilization.
The article explains why a seemingly harmless delete statement in an Oracle RAC+DG environment can become extremely slow, covering bind variable peek, execution‑plan changes, histogram effects, AWR/ASH analysis, rolling invalidation, and clustering factor, and shows how to diagnose and mitigate each issue.
This article explains how to identify and analyze MySQL slow queries using tools like SHOW VARIABLES, EXPLAIN, mysqldumpslow, and profiling, and provides practical recommendations for configuring server variables, optimizing indexes, and improving query performance through systematic testing and best‑practice SQL design.
This article explains essential Spark concepts, illustrates common performance bottlenecks, and provides concrete tuning strategies for memory, CPU, serialization, data locality, file I/O, and shuffle reduction, backed by real‑world examples and visual metrics.
This article explains what MariaDB Spider is, its role as a pluggable storage engine for MySQL/MariaDB sharding, demonstrates vertical and horizontal partitioning with real‑world Tencent game case, provides installation steps, configuration commands, performance considerations, tunable parameters, and load‑balancing architecture.
A colleague handed over a seemingly simple SQL Server query that ran in five seconds for early dates but never returned for later dates, and the article walks through the diagnosis, execution‑plan analysis, statistics update, and final fix that restored performance.
This article shares practical experiences and step‑by‑step guidance for migrating databases from Oracle to MySQL, covering pre‑migration preparation, target selection, data‑object migration tools such as SQL LOAD, Python scripts, Oracle GoldenGate, MySQL Migration Toolkit and Kettle, handling of views, triggers, stored procedures, data validation techniques, and key MySQL performance parameters.
The article reviews real‑world performance‑tuning practices from Netflix, RisingStack, and nearForm, explaining how they diagnose slow responses, CPU spikes, cryptographic overhead, and event‑loop blocking using techniques such as flame‑graph analysis, crypto profiling, and avoiding costly JSON.stringify operations.
This article explains Oracle's dynamic sampling feature, outlines typical scenarios such as temporary tables and complex filters, presents real CRM case studies with misestimated cardinalities, demonstrates step‑by‑step solutions using DBMS_STATS commands, and shows how 12c enhancements dramatically improve estimation accuracy for complex queries.
This article explains why frequent small commits are slower than a single bulk SQL operation, demonstrates how to rewrite PL/SQL procedures to use bulk inserts, adjust UNDO settings, and enable parallel execution, achieving up to six‑fold performance gains on large data loads.
This article outlines the five evolutionary stages of a MySQL deployment—table design, deployment, performance tuning, architecture scaling, and maintenance—detailing practical configuration tweaks, kernel and hardware optimizations, replication strategies, caching, sharding, partitioning, and essential monitoring and backup techniques.
This article shares actionable ETL tuning strategies for Inceptor, including avoiding unnecessary transaction tables, shortening transaction windows, analyzing the most impactful cases first, and iteratively refining steps until optimal performance is achieved.
This article explains SQL Server's logical and physical query execution order, offers practical techniques such as converting loops to batch operations, using temporary tables, optimizing indexes, and avoiding common pitfalls, all illustrated with code samples and performance measurements.
This article provides a step‑by‑step tutorial on preparing the environment, configuring the query analyzer, using SQL Server Profiler, and applying common commands such as clearing caches and enabling statistics to identify and resolve performance bottlenecks in SQL Server queries.
Facing a tight September release deadline, the author tackled two critical Oracle SQL performance issues by analyzing execution plans, replacing a costly view, applying driver‑table hints, removing unnecessary CASTs and a random‑number function, ultimately cutting query time from 11 seconds to under 2 seconds.
This guide walks through identifying the root cause of a SQL Server instance's 100% CPU usage using Profiler, analyzing the offending queries, and applying targeted index and query optimizations to dramatically reduce CPU consumption.
The article recounts a real‑world Oracle SQL case where a REGEXP_SUBSTR‑based IN subquery caused the optimizer to abandon an index range scan, explores why predicate pushdown fails with CONNECT BY recursion, documents attempted hints, rewrites, and the ultimate lessons for SQL performance tuning.
This article provides practical guidelines for designing efficient database schemas and optimizing SQL queries, covering row size limits, data type choices, index usage, common pitfalls in WHERE clauses, and best practices for temporary tables and transaction handling to improve overall database performance.
This article walks through a real‑world SQL Server case study, explaining how to assess system hardware, interpret performance counters and wait statistics, identify CPU, memory, disk and indexing issues, and apply a three‑stage optimization process to dramatically improve database performance.
A client reported intermittent database slowness, which was traced to high CXPACKET wait times; the article explains the CXPACKET mechanism, provides a diagnostic script, analyzes disk I/O bottlenecks, and offers practical recommendations such as faster disks, separating data and log files, and isolating large log tables.
The article details how Alibaba’s database team engineered multiple breakthroughs—PK_Access query optimization, a high‑performance Memcached plugin, batch‑processed inventory hotspot handling, full‑scale SQL collection, and an upgraded Data Replication Center—to dramatically boost Double‑11 transaction throughput, cut latency, and enhance overall system resilience.
This article outlines practical techniques for optimizing large MySQL tables—including column and index tuning, query improvements, engine selection, system parameters, hardware upgrades, caching, partitioning, vertical and horizontal sharding, and discusses client‑side and proxy‑based sharding solutions and compatible databases.
This article explains how to navigate Inceptor's Stage information page, interpret Summary Metrics, Aggregated Metrics by Executor, and Task details, and use DAG Visualization and Event Timeline charts to diagnose performance issues and optimize big‑data workloads.
This article explains what execution plans are, why seemingly identical SQL statements can produce different plans, and offers practical tips—such as standardizing query syntax, simplifying nested queries, using temporary tables, bind variables, appropriate transaction scopes, and careful use of NOLOCK—to improve database performance and avoid common pitfalls.
This article demonstrates step‑by‑step how Oracle DBAs can identify the origin of recursive SQL statements by leveraging the 10046 trace at both SQL‑ID and session levels, analyzing the trace with the Orasrp tool, and ultimately pinpointing the PL/SQL function that generated the query.
After a typhoon delayed work, the author tackled a 347‑line Oracle SQL that took over four minutes to return results, dissected its massive subqueries and views, applied three rounds of restructuring with WITH clauses and driver‑table tactics, and ultimately reduced the total runtime to just 3.5 seconds while dramatically speeding up deep data extraction.
The article explains the CXPACKET wait type in SQL Server, shows how to identify it with diagnostic queries, illustrates its parallelism mechanism with analogies and diagrams, and provides practical steps and hardware recommendations to resolve performance slowdowns caused by this wait.
This guide explains when and why Oracle statistics are needed, how to control automatic and manual collection, prevent out‑of‑range errors, boost efficiency with parallel and incremental methods, and handle special cases like volatile or temporary tables for optimal query performance.
This article compiles the most discussed DBA questions from multiple WeChat groups in November, covering DB2 query latency, Oracle import/export challenges, MySQL monitoring, SQL performance nuances, partition table design, and practical solutions shared by experts.
A detailed Oracle performance case study shows how adding selective predicates and a supporting index to an UPDATE that runs hourly can reduce redo log generation from over 100 MB to under 1 MB and cut logical reads by more than 95%, with step‑by‑step measurements and code examples.
Learn how to diagnose and resolve common Java performance issues such as OutOfMemoryError, thread deadlocks, and high CPU usage by using built‑in JVM tools—including jps, jstack, jmap, jhat, jstat, and hprof—through detailed command examples, output explanations, and practical profiling techniques.
This comprehensive MySQL guide covers logging in, starting and stopping the service, checking status, listing databases, describing tables, transaction support, storage engine differences, privilege tables, repair methods, performance commands, and the best column types for monetary values.
This guide explains MongoDB read preference options, write concerns, authentication setup, replica set configuration, and connection best practices with PHP examples, helping developers improve database performance and avoid common pitfalls in production environments.
This guide explains essential MySQL InnoDB parameters—such as buffer pool size, instances, connection limits, log buffer, statistics collection, lock timeout, thread concurrency, and I/O threads—and provides practical CPU‑based settings to help you optimize database performance.
This article shares hands‑on experience from Spark Summit attendees, covering why Spark is powerful, common performance problems such as slow jobs, OOM, data skew, excessive partitions, and provides concrete tuning advice on executors, cores, memory, and debugging techniques.
This article presents a comprehensive set of practical strategies for improving database query performance, covering index design, SQL statement refinements, Java backend considerations, hardware tuning, and storage‑procedure usage to accelerate operations on large‑scale relational databases.
This article explores Oracle's Hint feature, reviewing its classification, demonstrating how improper use can degrade performance, presenting real‑world negative cases, and summarizing Oracle's official stance and best‑practice recommendations for when and how to apply Hints effectively.
The G1 Garbage‑First collector is a server‑side, region‑based Java GC designed for multi‑processor, large‑memory systems that concurrently marks objects using SATB, tracks cross‑region references with RSets, and employs a pause‑prediction model to meet user‑specified pause‑time goals while maintaining high throughput.
The article dissects a moderately complex Oracle SQL query from a data‑warehouse, shows how changing a parallel hint forces a full table scan that halves execution time, and then explores partitioning strategies and broader lessons on OLAP performance tuning.
This article explains why Zabbix's original table design slows down data insertion and query in large‑scale deployments, and provides a step‑by‑step code‑level optimization that creates separate "latest" tables with primary‑key indexes, modifies the server source, and updates the front‑end query to dramatically improve performance without affecting historical data ingestion.
This article walks through the major MySQL 5.7 enhancements—including InnoDB buffer‑dump improvements, multi‑threaded page cleaning, dynamic buffer‑pool resizing, global tablespaces, default DYNAMIC row format, native partitioning, truncate‑undo logs, native JSON support, sys schema, optimizer hints, trigger upgrades, syslog integration, and virtual columns—providing practical steps, examples, and usage tips for DBAs.
This article outlines the lifecycle of a mature MySQL database architecture, covering table design, deployment, performance tuning, scaling strategies such as replication, sharding and partitioning, as well as maintenance tasks like monitoring, backup, and repair, with practical configuration examples.
This article examines a recurring ORA-00600 crash caused by Oracle MERGE statements, walks through reproducing the issue, analyzes the impact of bound variables and table size, identifies a version‑specific bug, and offers practical work‑arounds and recommendations for DBAs.
This article shares a real-world case study of migrating a SQL Server 2008 R2 environment to SQL Server 2014, detailing the pre‑migration research, architecture redesign with AlwaysOn high‑availability, testing procedures, implementation steps, performance tuning, and common pitfalls encountered during the three‑month project.
This article explains how major companies keep MySQL fast at massive scale and provides practical techniques—including schema design, InnoDB advantages, table compression, bulk loading order, and hardware choices—to optimize MySQL performance for billions‑row tables.
During performance testing, an Oracle SQL using bind variables showed two child cursors with identical execution plans; the article explains this phenomenon by detailing Oracle’s rolling cursor invalidation mechanism, the role of the ROLL_INVALID_MISMATCH flag, and how to reproduce and observe it.
An experienced DBA shares a real-world case of optimizing a nightly Oracle reporting pipeline, detailing how partitioned tables, truncate operations, table compression, disabling logging, and parallel execution reduced a 20‑hour data extraction to under one hour, and compiles community‑sourced tuning tips for large‑scale data warehouses.
This article walks through a real‑world case study of a hospital HIS running on SQL Server 2008R2, detailing the system’s hardware specs, performance metrics, three‑phase optimization process—including general tuning, statement‑level fixes, and deep CPU/memory analysis—and the measurable results achieved without adding new hardware.
This guide explains how to monitor Oracle UNDO tablespace usage, adjust automatic UNDO management parameters, interpret V$UNDOSTAT statistics, and safely reclaim space by creating a new UNDO tablespace and dropping the old one, helping DBAs avoid ORA‑01555 errors and space shortages.
This comprehensive presentation explores SQL’s history, its enduring relevance amid NoSQL and NewSQL trends, explains the execution order and optimizer mechanics, offers practical optimization rules and step‑by‑step execution processes, and illustrates concepts through multiple real‑world case studies and a detailed Q&A.
Learn ten practical strategies—from careful schema design and precise SELECT statements to query caching, index creation, and smart use of JOINs, LIMIT, UNION, and wildcards—that dramatically improve database speed and reduce server load on high‑traffic websites.
This article walks through diagnosing severe I/O spikes in a MySQL project, explains SSD characteristics, and provides step‑by‑step InnoDB parameter tweaks, I/O scheduler changes, and monitoring results that lead to a stable, balanced database performance on SSD storage.
This guide shares a detailed recount of preparing for the Oracle OCM certification, covering exam locations, odd/even machine handling, required software installations, crash scenarios, step‑by‑step skillset tasks, and practical review tips to help candidates succeed.
This article explains two practical techniques for identifying Oracle hidden parameters—querying internal views like GV$PARAMETER and X$ tables, and using AUTOTRACE to inspect execution plans—so DBAs can reveal undocumented settings, their defaults, and current values.
The article describes a slow PL/SQL Developer experience on an Oracle 12.1.0.2 test database, explains how missing dictionary and fixed object statistics cause delays, shows how to gather these stats, disable optimizer_dynamic_sampling, and restart the database to significantly improve query and autocomplete performance.
This guide outlines comprehensive MySQL performance tuning techniques, covering architectural replication, system‑level hardware adjustments, MySQL configuration parameters, and application‑level query optimizations with specific recommended values for buffers, caches, and connection limits.
This article explains the theory behind SQL Server's parallel execution, illustrates its performance gains with Amdahl's Law, lists operators that block parallelism, discusses configuration settings, warns of deadlocks and thread starvation, and presents practical MapReduce‑style optimizations for real‑world workloads.
This article provides a comprehensive guide on tackling Spark performance bottlenecks by diagnosing data skew, locating the offending stages and operators, and applying a range of practical solutions—including Hive pre‑processing, key filtering, shuffle parallelism, two‑stage aggregation, map‑join, and combined strategies—followed by an in‑depth discussion of shuffle manager evolution and key configuration parameters for fine‑tuning.
This article compiles a comprehensive set of Oracle SQL queries that monitor wait events, rollback segment contention, tablespace and file system I/O ratios, SGA hit rates, dictionary cache efficiency, MTS activity, fragmentation, and other critical performance metrics, often with recommended threshold values.
This article explains Linux's memory architecture, covering physical and virtual memory differences between 32‑bit and 64‑bit systems, memory zones, the buddy allocator, page reclamation, and swap handling, providing essential knowledge for performance tuning and system optimization.
This article explains the Linux I/O scheduler layer, details the three main scheduling algorithms—CFQ, deadline, and noop—their internal mechanisms, tunable parameters, and provides guidance on selecting the appropriate scheduler for different storage workloads.
This comprehensive guide enumerates over forty common causes of slow SQL Server queries and provides detailed optimization techniques—including indexing strategies, hardware upgrades, partitioning, cursor handling, and configuration tweaks—to dramatically improve query performance and reduce resource bottlenecks.
This guide outlines concrete strategies to reduce I/O and CPU overhead in Oracle queries, covering scope reduction, partition pruning, join simplification, hint usage, bind variables, and common pitfalls like Cartesian products and inefficient filters.
This article explains Oracle's parallel execution features—including parallel query, DML, and DDL—covers object, session, and statement level settings, provides practical SQL examples, discusses common pitfalls, and presents performance test results that demonstrate significant speed improvements for large data migration tasks.
This guide details the most effective Oracle Data Pump parameters and related database settings—such as access_method, parallel, network_link, and NLS options—to dramatically improve export and import performance while avoiding common pitfalls.
This guide explains how to use MySQL's SHOW GLOBAL STATUS and SHOW VARIABLES outputs to identify and adjust key parameters such as slow query logging, connection limits, key buffer size, temporary tables, open tables, thread cache, query cache, sorting, file handles, table locks, and table scans for optimal database performance.
This guide explains practical MySQL optimization techniques—including selecting InnoDB vs. MyISAM, avoiding COUNT(*), using EXPLAIN, and adding selective indexes—to dramatically reduce query time and prevent full‑table scans.
This article shares practical Oracle DBA experiences—including role definitions, environment considerations, monitoring strategies, performance‑tuning case studies, development‑business integration, and future‑oriented operations—offering concrete guidance and hard‑won insights for database administrators.
This article explains a systematic, waiting‑point‑based approach to enterprise Java performance tuning, covering load‑test design, analysis of existing versus new applications, hierarchical and technical waiting points, pool and cache sizing, and a back‑tuning workflow to achieve measurable improvements.
Discover six powerful techniques—including B‑tree and bitmap indexes, materialized views, result‑set caching, and clever query rewrites—to dramatically reduce logical reads and accelerate Oracle's SELECT COUNT(*) performance, with step‑by‑step examples and measurable improvements.
This article examines why storage capacity limits IT systems, explains how database compression reduces disk usage and I/O time, discusses various dictionary‑based compression methods, related operations and commands, and evaluates compression ratios and overall impact on system performance.
NGINX 1.9.1 adds the SO_REUSEPORT socket option, allowing multiple workers to share the same IP and port, which the kernel load‑balances, reducing lock contention and dramatically improving request throughput and latency in multi‑core environments.
This guide explains why the ORA-01555 "snapshot too old" error occurs in Oracle databases, where related logs are stored, the underlying UNDO and LOB mechanisms that trigger it, and step‑by‑step solutions to diagnose and eliminate the problem.
This article walks through practical Oracle SQL optimization methods—explaining execution plans, indexes, statistics, hints, and partitioning—using concrete examples and step‑by‑step case studies that show how to dramatically reduce query runtimes and CPU load.
This guide explains Oracle Real‑Time SQL Monitoring, covering terminology, activation conditions, how to access it via Enterprise Manager Cloud Control, and detailed walkthroughs of its various panels, metrics, and practical examples for diagnosing and optimizing long‑running queries and index builds.
This article compiles Russell Smith’s comprehensive MongoDB best‑practice guide, covering architecture choices, file limits, write safety, schema design, replication, sharding, security, and performance tuning to help engineers avoid common pitfalls and optimize production deployments.
A slow Oracle OLTP query that consumed 56% of DB resources and averaged 28 seconds per execution was dramatically accelerated to millisecond response time by forcing the proper index, refreshing stale table statistics, and ultimately creating a cn + c_date composite index.
This article outlines practical strategies for Oracle DBAs to design, automate, and fine‑tune statistics‑gathering processes in large, high‑concurrency environments, covering automatic options, handling skewed data, partitioned tables, bind variables, and ongoing optimization cycles.
This article explains how Dianping built a millisecond‑level real‑time computation platform using Apache Storm, covering use cases, system architecture, core Storm concepts, performance tuning, best practices, and a detailed Q&A on their production deployment.
This comprehensive guide explains the essence of Oracle SQL tuning, presents a step‑by‑step optimization roadmap, walks through real‑world case studies—including a high‑CPU query fixed with hints and query rewrites—and details how to capture and interpret accurate execution plans while addressing optimizer parameters and common pitfalls.
In this detailed DBA case study, the speaker explains how improper settings of Oracle's parallel execution parameters on an AIX‑based 10gR2 database led to process saturation, undo‑related wait events, and temporary connection issues, and describes the step‑by‑step diagnosis, parameter adjustments, and lessons learned for future tuning.
This article explains how to measure a system's load capacity, identifies key factors such as bandwidth, hardware, and OS settings, and provides practical optimization techniques for Linux, Nginx, Tomcat, and databases to achieve higher concurrency and better performance.
This article presents a detailed case study of an Oracle RAC system performance bottleneck, walks through comprehensive monitoring, storage and partitioning analysis, and outlines a step‑by‑step optimization plan—including KEEP pool tuning and partition redesign—that dramatically improved I/O latency and overall throughput.
