BestHub
Sign in
Tagged articles

pagination

325 articles · Page 3 of 4
Architect
Architect
Jul 8, 2022 · Backend Development

Understanding Feed Stream Architecture: Models, Storage, and Optimization

This article explains the concept of feed streams, compares push and pull implementation models, discusses storage options such as MySQL, Redis SortedSet and Cassandra, and presents optimization techniques including online‑push/offline‑pull strategies, pagination methods, and deep‑paging solutions for large‑scale systems.

CassandraSystem Optimizationbackend-architecture
0 likes · 9 min read
Understanding Feed Stream Architecture: Models, Storage, and Optimization
ITPUB
ITPUB
Jun 14, 2022 · Databases

12 Common MySQL Slow‑Query Causes and How to Fix Them

This article enumerates twelve typical reasons why MySQL queries become slow—such as missing or ineffective indexes, deep pagination, massive tables, excessive joins, large IN lists, dirty pages, file‑based ORDER BY, and hardware limits—and provides concrete SQL examples and step‑by‑step optimization techniques to resolve each issue.

Database PerformanceIndex OptimizationSlow Query
0 likes · 33 min read
12 Common MySQL Slow‑Query Causes and How to Fix Them
Top Architect
Top Architect
Jun 6, 2022 · Big Data

Optimizing Large‑Scale Data Pagination with ClickHouse, Elasticsearch, HBase, and Redis

This article presents a comprehensive analysis and multiple optimization strategies—including multithreaded ClickHouse pagination, Elasticsearch scroll‑scan, an ES‑HBase hybrid approach, and RediSearch + RedisJSON—to efficiently filter and sort up to 10 W records from a pool of tens of millions while reducing query latency and system complexity.

ClickHouseHBasepagination
0 likes · 11 min read
Optimizing Large‑Scale Data Pagination with ClickHouse, Elasticsearch, HBase, and Redis
Sohu Tech Products
Sohu Tech Products
May 11, 2022 · Backend Development

Elasticsearch Pagination: From/Size, Deep Paging Issues, Scroll, Search After, PIT and Best Practices

This article explains Elasticsearch pagination mechanisms—including from/size, deep paging drawbacks, scroll, scroll‑scan, sliced scroll, search_after and point‑in‑time—detailing their inner workings, performance trade‑offs, configuration limits, and practical recommendations for handling large result sets.

Deep PagingElasticsearchSearch
0 likes · 17 min read
Elasticsearch Pagination: From/Size, Deep Paging Issues, Scroll, Search After, PIT and Best Practices
Java Backend Technology
Java Backend Technology
Apr 28, 2022 · Databases

Why MySQL Pagination Slows Down at High Offsets and How to Fix It

This article recounts a production incident caused by a MySQL query with a huge OFFSET, explains why large offsets lead to full‑table scans and severe latency, and presents three practical solutions—including index‑covering subqueries, start‑position redefinition, and offset throttling—along with data‑generation scripts and performance test results.

Index OptimizationSQLmysql
0 likes · 14 min read
Why MySQL Pagination Slows Down at High Offsets and How to Fix It
Programmer DD
Programmer DD
Apr 14, 2022 · Databases

How to Speed Up MySQL LIMIT Pagination from 16 s to 0.3 s with Subquery Optimization

This article demonstrates how a MySQL pagination query on a 9.5‑million‑row table that originally took over 16 seconds can be accelerated to under 0.4 seconds by moving the LIMIT condition into a subquery that selects only primary‑key IDs and then joining to retrieve the remaining columns, with detailed code and experimental verification.

InnoDBLimit OptimizationPerformance Tuning
0 likes · 10 min read
How to Speed Up MySQL LIMIT Pagination from 16 s to 0.3 s with Subquery Optimization
Open Source Linux
Open Source Linux
Mar 29, 2022 · Databases

Essential MySQL SQL Optimization Tips to Speed Up Your Queries

This guide presents a comprehensive set of MySQL optimization techniques—including proper use of EXPLAIN, limiting IN clause size, avoiding SELECT *, using LIMIT 1, minimizing sorting, replacing OR with UNION ALL, preferring UNION ALL over UNION, eliminating ORDER BY RAND(), distinguishing IN versus EXISTS, applying efficient pagination, segmenting large scans, avoiding NULL checks and leading wildcards, rewriting expressions, preventing implicit type conversion, respecting composite index leftmost rules, forcing indexes, handling range queries, and optimizing JOINs—to dramatically improve query performance.

Database PerformanceEXPLAINIndexing
0 likes · 11 min read
Essential MySQL SQL Optimization Tips to Speed Up Your Queries
Java High-Performance Architecture
Java High-Performance Architecture
Mar 24, 2022 · Databases

How to Efficiently Query Millions of Rows in MySQL: Pagination Tricks and Optimizations

This article walks through generating a 10‑million‑row MySQL table, inserting data with a fast batch script, measuring plain LIMIT pagination performance, and applying several optimization techniques—including sub‑queries, ID‑range filtering, and column selection—to dramatically reduce query time on large data sets.

Batch Insertmysqlpagination
0 likes · 9 min read
How to Efficiently Query Millions of Rows in MySQL: Pagination Tricks and Optimizations
Top Architect
Top Architect
Jan 22, 2022 · Databases

Optimizing MySQL Pagination Queries with Subqueries and Buffer‑Pool Analysis

The article explains why large‑offset LIMIT queries on a MySQL table with millions of rows are slow, demonstrates how rewriting the query to use a subquery that first selects primary‑key IDs dramatically reduces execution time, and validates the improvement by measuring buffer‑pool page usage.

Buffer PoolDatabase PerformanceQuery Optimization
0 likes · 9 min read
Optimizing MySQL Pagination Queries with Subqueries and Buffer‑Pool Analysis
Code DAO
Code DAO
Jan 18, 2022 · Backend Development

Implementing Pagination, Filters, and Error Handling in a Go Clean Architecture with Ent and gqlgen (Part 3)

This tutorial walks through adding pagination and flexible where‑filters to the User List interface, configuring gqlgen extensions, handling GraphQL errors, wrapping mutations in transactions, and building unit, integration, and end‑to‑end tests for a Go clean‑architecture project using Ent and gqlgen.

Clean ArchitectureError handlingGo
0 likes · 23 min read
Implementing Pagination, Filters, and Error Handling in a Go Clean Architecture with Ent and gqlgen (Part 3)
Python Crawling & Data Mining
Python Crawling & Data Mining
Jan 16, 2022 · Fundamentals

Master Web Scraping with Chrome’s Web Scraper: Install, Sitemap & Advanced Pagination

This guide walks you through installing the Chrome Web Scraper extension, explains core concepts like sitemaps and selectors, and demonstrates how to handle both simple and complex pagination as well as secondary page crawling, enabling you to extract structured data from websites without writing code.

Chrome ExtensionSitemappagination
0 likes · 9 min read
Master Web Scraping with Chrome’s Web Scraper: Install, Sitemap & Advanced Pagination
Code DAO
Code DAO
Jan 15, 2022 · Backend Development

Implementing Clean Architecture with ent and gqlgen – Part 2

This article walks through integrating the four Clean Architecture layers—entity, use‑case, interface‑adapter, and framework/driver—into a Go application using ent for ORM and gqlgen for GraphQL, covering folder layout, ULID primary keys, Node interface support, and pagination implementation.

Clean ArchitectureGoGraphQL
0 likes · 19 min read
Implementing Clean Architecture with ent and gqlgen – Part 2
Java Backend Technology
Java Backend Technology
Jan 15, 2022 · Databases

Why Large OFFSETs Slow MySQL Queries and How Subquery Optimization Fixes It

The article explains how using a large OFFSET in MySQL pagination forces the server to read and discard many rows, causing severe performance degradation, and demonstrates that rewriting the query to first fetch primary‑key IDs via a subquery dramatically reduces I/O and execution time, with buffer‑pool experiments confirming the improvement.

Buffer PoolQuery OptimizationSubquery
0 likes · 9 min read
Why Large OFFSETs Slow MySQL Queries and How Subquery Optimization Fixes It
21CTO
21CTO
Jan 10, 2022 · Backend Development

Mastering REST vs RESTful: Key Differences, Best Practices, and Future Trends

This comprehensive guide explains the origins and definitions of REST and RESTful, outlines core architectural constraints, compares terminology, presents best‑practice API design patterns—including URI conventions, HTTP methods, error handling, filtering, pagination, versioning, and health checks—while evaluating the future role of REST versus GraphQL.

API designFilteringHTTP
0 likes · 30 min read
Mastering REST vs RESTful: Key Differences, Best Practices, and Future Trends
NiuNiu MaTe
NiuNiu MaTe
Dec 15, 2021 · Databases

Master MySQL Performance: Practical Tuning, Indexes, and Scaling Strategies

This comprehensive guide walks through MySQL performance fundamentals, real‑world testing results, slow‑query detection, index impact, pagination pitfalls, count optimizations, sharding techniques, and step‑by‑step migration plans for large tables, equipping engineers with actionable tuning insights.

Index OptimizationShardingdatabase scaling
0 likes · 13 min read
Master MySQL Performance: Practical Tuning, Indexes, and Scaling Strategies
Java Interview Crash Guide
Java Interview Crash Guide
Dec 7, 2021 · Databases

Why Traditional Pagination Fails After Sharding and How to Solve It

When a table grows beyond ten million rows, sharding it across multiple databases improves performance, but the usual LIMIT offset, pagesize pagination breaks, leading to missing or incorrect records; this article examines why simple merge approaches fail and evaluates global, secondary query, and no‑skip paging strategies, highlighting their trade‑offs.

SQLShardingdatabase
0 likes · 12 min read
Why Traditional Pagination Fails After Sharding and How to Solve It
Senior Brother's Insights
Senior Brother's Insights
Oct 28, 2021 · Databases

Why MySQL LIMIT Can Return Duplicate Rows and How to Fix It

In a production environment, a pagination export feature caused duplicate and missing records due to MySQL’s nondeterministic ordering when multiple rows share the same ORDER BY value, and the article explains the root cause, official documentation, and a reliable solution using additional sorting columns.

LIMITOrder ByQuery Optimization
0 likes · 10 min read
Why MySQL LIMIT Can Return Duplicate Rows and How to Fix It
IT Architects Alliance
IT Architects Alliance
Oct 14, 2021 · Backend Development

Best Practices for Designing Robust APIs

This article explains why APIs are essential, how to model data and resources, apply RESTful principles, choose clear naming conventions, manage versioning, and implement pagination, providing practical guidelines and code examples for building maintainable and developer‑friendly backend services.

API designRESTpagination
0 likes · 8 min read
Best Practices for Designing Robust APIs
ITPUB
ITPUB
Oct 12, 2021 · Databases

How to Handle Pagination After MySQL Sharding: Pitfalls and Solutions

When a MySQL table is sharded into multiple databases or tables, the usual LIMIT offset, pagesize pagination breaks, and this article examines why simple merge fails, then presents three practical approaches—global limit, secondary queries, and jump‑page restriction—highlighting their trade‑offs and limitations.

SQLShardingdatabase
0 likes · 13 min read
How to Handle Pagination After MySQL Sharding: Pitfalls and Solutions
macrozheng
macrozheng
Oct 8, 2021 · Databases

How to Speed Up MySQL Deep Pagination: 4 Proven Optimization Techniques

This article explains why MySQL LIMIT deep pagination becomes slow with large offsets and presents four practical optimization methods—including subqueries, delayed INNER JOIN, tag‑recording, and BETWEEN…AND—demonstrated with real‑world production examples.

Query OptimizationSQLmysql
0 likes · 11 min read
How to Speed Up MySQL Deep Pagination: 4 Proven Optimization Techniques
ITPUB
ITPUB
Aug 19, 2021 · Databases

Why Does MySQL LIMIT with ORDER BY Return Duplicate Rows on Page 2?

When using MySQL pagination with LIMIT together with ORDER BY, the second page can unexpectedly contain rows from the first page because MySQL 5.6's priority‑queue optimization performs an unstable heap sort, causing nondeterministic ordering for equal values and leading to duplicate results.

LIMITOrder Bydatabase
0 likes · 7 min read
Why Does MySQL LIMIT with ORDER BY Return Duplicate Rows on Page 2?
Tencent Cloud Developer
Tencent Cloud Developer
Aug 10, 2021 · Backend Development

Backend Storage Design for Timeline Feed Streams: Read Diffusion, Write Diffusion, and Hybrid Approaches

Backend storage for timeline feeds can use read‑diffusion (pull), write‑diffusion (push), or a hybrid mix, each with trade‑offs in read/write load, scalability, and storage, while pagination should rely on last_id and snapshots for state‑driven ordering such as live‑streaming feeds.

Live Streamingpaginationread diffusion
0 likes · 17 min read
Backend Storage Design for Timeline Feed Streams: Read Diffusion, Write Diffusion, and Hybrid Approaches
Ctrip Technology
Ctrip Technology
Jul 15, 2021 · Frontend Development

Optimizing List Rendering Performance in Taro3 Using a Custom Virtual List

This article examines the performance bottlenecks of a Taro3 mini‑program list page after migrating from Taro1, analyzes causes such as excessive node rendering and large setState payloads, evaluates backend pagination and the built‑in virtual list, and presents a custom virtual‑list implementation that reduces rendered nodes, uses screen‑height placeholders, and achieves roughly 45% faster rendering and 50% quicker interaction response.

IntersectionObserverReActTaRO
0 likes · 12 min read
Optimizing List Rendering Performance in Taro3 Using a Custom Virtual List
DeWu Technology
DeWu Technology
Jul 2, 2021 · Databases

MySQL Deep Pagination Optimization

MySQL deep pagination can be dramatically accelerated by ordering on the primary key, indexing the sort column, and using keyset pagination or a sub‑query join instead of scanning millions of rows, while only minor tweaks like increasing sort_buffer_size provide negligible gains.

IndexingSQLdeep pagination
0 likes · 10 min read
MySQL Deep Pagination Optimization
Top Architect
Top Architect
Jun 30, 2021 · Databases

Analyzing and Optimizing MySQL Pagination Performance with Large Offsets

This article investigates why MySQL queries with large LIMIT offsets become extremely slow, demonstrates the issue with simulated millions‑of‑row datasets, and presents three optimization strategies—including index‑covering subqueries, remembering the last primary‑key position, and applying offset throttling—to achieve consistent, fast pagination performance.

IndexingOptimizationSQL
0 likes · 12 min read
Analyzing and Optimizing MySQL Pagination Performance with Large Offsets
IT Xianyu
IT Xianyu
Jun 10, 2021 · Backend Development

Comprehensive Guide to MyBatis-Plus: CRUD, Annotations, Condition Builders, Pagination, and Advanced Features

This article provides a detailed tutorial on using MyBatis-Plus in Java, covering setup, entity and mapper definitions, CRUD operations, annotations, condition builders, pagination, AR mode, logical deletion, automatic field filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, configuration options, and code generation.

CRUDJavaORM
0 likes · 45 min read
Comprehensive Guide to MyBatis-Plus: CRUD, Annotations, Condition Builders, Pagination, and Advanced Features
IT Architects Alliance
IT Architects Alliance
Jun 7, 2021 · Databases

Analyzing and Optimizing MySQL Pagination Performance with Large Offsets

The article examines a production MySQL query that suffers severe slowdown due to large LIMIT offsets, demonstrates how to reproduce the issue with massive test data, analyzes the root cause, and presents three optimization strategies—including index covering, keyset pagination, and offset limiting—to dramatically improve query performance.

IndexingOptimizationSQL
0 likes · 13 min read
Analyzing and Optimizing MySQL Pagination Performance with Large Offsets
Architect
Architect
Jun 6, 2021 · Databases

Optimizing MySQL Pagination for Large Datasets: Analysis and Solutions

An engineer describes a production MySQL pagination issue where large offset queries caused severe slowdown, analyzes the root cause, demonstrates data simulation scripts, and presents three optimization strategies—including index covering with subqueries, redefining start positions, and applying offset limits—to improve query performance on massive tables.

Performance OptimizationSQLdatabase
0 likes · 13 min read
Optimizing MySQL Pagination for Large Datasets: Analysis and Solutions
Java Interview Crash Guide
Java Interview Crash Guide
May 30, 2021 · Backend Development

Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Advanced Tips

This comprehensive tutorial demonstrates how to integrate MyBatis-Plus with Spring Boot, covering basic setup, entity and mapper creation, CRUD operations, condition wrappers, pagination, logical deletion, automatic field filling, optimistic locking, and advanced features such as multi‑tenant and dynamic table name handling, complete with code examples.

CRUDLogical DeletionOptimistic Locking
0 likes · 46 min read
Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Advanced Tips
Code Ape Tech Column
Code Ape Tech Column
May 11, 2021 · Databases

How to Speed Up MySQL LIMIT Pagination for Millions of Rows

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.

LIMITSQLindex
0 likes · 12 min read
How to Speed Up MySQL LIMIT Pagination for Millions of Rows
Architecture Digest
Architecture Digest
May 9, 2021 · Databases

Optimizing MySQL Pagination with LIMIT: Methods, Experiments, and Index Strategies

This article examines the performance drawbacks of MySQL's LIMIT pagination on large tables, presents six practical query methods—including direct LIMIT, primary‑key indexing, index‑based ordering, prepared statements, covering indexes, and sub‑query/join techniques—provides extensive benchmark results, and offers concrete indexing recommendations to achieve fast, stable pagination even with millions of rows.

IndexingLIMITLarge Data
0 likes · 12 min read
Optimizing MySQL Pagination with LIMIT: Methods, Experiments, and Index Strategies
Code Ape Tech Column
Code Ape Tech Column
May 8, 2021 · Databases

Understanding MySQL Pagination Performance and Index Optimization

The article explores why MySQL pagination with large offsets is slow, explains index structures such as clustered and secondary indexes, describes logical query operators, and presents two practical optimization strategies to improve query performance.

Database PerformanceIndex OptimizationQuery Planning
0 likes · 6 min read
Understanding MySQL Pagination Performance and Index Optimization
Programmer DD
Programmer DD
May 7, 2021 · Databases

Boost MySQL Pagination Performance: Real-World Tests and Optimizations

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.

Database PerformanceQuery OptimizationSQL
0 likes · 10 min read
Boost MySQL Pagination Performance: Real-World Tests and Optimizations
Big Data Technology Architecture
Big Data Technology Architecture
May 6, 2021 · Databases

Elasticsearch Pagination: From+size, search_after, and Scroll – Differences, Advantages, and Use Cases

This article explains Elasticsearch’s three pagination methods—From + size, search_after, and Scroll—detailing their definitions, code examples, advantages, disadvantages, and suitable scenarios, while also discussing max_result_window limits, PIT views, and best practices for handling large result sets.

ElasticsearchSearchbackend
0 likes · 13 min read
Elasticsearch Pagination: From+size, search_after, and Scroll – Differences, Advantages, and Use Cases
Programmer DD
Programmer DD
May 6, 2021 · Backend Development

Building a Fast Search with Redis: From Complex SQL to Set Operations

This article walks through the challenges of implementing a complex e‑commerce search interface, compares a naïve SQL solution with optimized multi‑query and Redis‑based approaches, and demonstrates how to use Redis sets, sorted sets, and transactions to achieve efficient querying, pagination, and data updates.

SearchSet Operationsbackend
0 likes · 9 min read
Building a Fast Search with Redis: From Complex SQL to Set Operations
Code Ape Tech Column
Code Ape Tech Column
May 6, 2021 · Backend Development

Why PageHelper Pagination Breaks with List Operations and How to Fix It

This article explains why PageHelper pagination yields incorrect totals when list operations are performed before or after pagination, analyzes the underlying cause that startPage only affects subsequent SQL, and provides a step‑by‑step solution that processes the list after pagination and returns a correctly populated PageInfo object.

JavaMyBatisSpring
0 likes · 6 min read
Why PageHelper Pagination Breaks with List Operations and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
May 4, 2021 · Backend Development

Building a Reusable Backend Base Project with Swagger, CodeGenerator, Pagination, Exception Handling, and Multi‑Environment Configuration

This article explains how to create a reusable backend foundation for new Spring Boot projects by assembling common utilities such as Swagger API documentation, MyBatis‑Plus code generation, unified response objects, pagination helpers, custom exception handling, multi‑environment Maven and Spring profiles, logback configuration, and a Jenkins pipeline.

JavaSpring Bootbackend
0 likes · 15 min read
Building a Reusable Backend Base Project with Swagger, CodeGenerator, Pagination, Exception Handling, and Multi‑Environment Configuration
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2021 · Backend Development

Master MyBatis-Plus: From Basics to Advanced CRUD, Pagination, and Code Generation

This comprehensive guide walks you through MyBatis-Plus fundamentals, non‑intrusive features, quick project setup, CRUD operations, automatic field filling, optimistic and logical locking, powerful wrapper queries, pagination, and the built‑in code generator, all illustrated with runnable examples and code snippets.

CRUDJavaLogical Delete
0 likes · 25 min read
Master MyBatis-Plus: From Basics to Advanced CRUD, Pagination, and Code Generation
Programmer DD
Programmer DD
Apr 6, 2021 · Databases

Why MySQL Pagination Is So Slow and How to Fix It

This article explores why MySQL queries with large LIMIT‑OFFSET pagination become painfully slow, explains the underlying B+‑tree index mechanics and MySQL's logical operator layers, and presents two practical solutions—key‑based pagination and index‑covering queries—to dramatically improve performance.

B+TreeDatabase PerformanceIndex Optimization
0 likes · 7 min read
Why MySQL Pagination Is So Slow and How to Fix It
MaGe Linux Operations
MaGe Linux Operations
Mar 20, 2021 · Backend Development

Mastering Elasticsearch Distributed Search: Performance Tips & Pagination Strategies

This article examines Elasticsearch’s distributed search architecture, explains the two‑phase query and fetch process, identifies performance and relevance scoring challenges, and presents optimization techniques such as Search After with point‑in‑time, Scroll API usage, and DFS query‑then‑fetch for accurate scoring.

Distributed SearchElasticsearchPerformance Optimization
0 likes · 9 min read
Mastering Elasticsearch Distributed Search: Performance Tips & Pagination Strategies
Code Ape Tech Column
Code Ape Tech Column
Mar 15, 2021 · Databases

Why Large OFFSETs Slow MySQL Queries and How to Fix Them

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.

Index OptimizationKeyset PaginationLarge OFFSET
0 likes · 16 min read
Why Large OFFSETs Slow MySQL Queries and How to Fix Them
php Courses
php Courses
Feb 22, 2021 · Backend Development

Customizing Laravel Pagination for Pseudo‑Static URLs

This guide explains how to override Laravel's built‑in pagination component to generate clean pseudo‑static URLs by creating a custom LengthAwarePaginator, rewriting its url method, and providing a staticPaginate scope for selective use.

LaravelPHPPseudo-Static
0 likes · 7 min read
Customizing Laravel Pagination for Pseudo‑Static URLs
Top Architect
Top Architect
Feb 17, 2021 · Backend Development

Understanding and Optimizing MyBatis PageHelper Pagination Performance

This article analyzes the performance bottlenecks of PageHelper's pagination in MyBatis, demonstrates how large offsets degrade MySQL query speed, and presents a more efficient sub‑query join solution along with suggestions for refactoring the interceptor to improve backend pagination efficiency.

JavaMyBatisSQL
0 likes · 9 min read
Understanding and Optimizing MyBatis PageHelper Pagination Performance
Code Ape Tech Column
Code Ape Tech Column
Jan 12, 2021 · Backend Development

How to Build a High‑Performance Search API with SQL and Redis Caching

This article walks through three progressively better implementations for a complex e‑commerce search API—starting with a monolithic SQL query, then splitting the query and adding indexes, and finally using Redis sets and sorted sets to cache filter results, handle pagination, and achieve production‑grade performance.

RedisSQLbackend
0 likes · 8 min read
How to Build a High‑Performance Search API with SQL and Redis Caching
21CTO
21CTO
Jan 5, 2021 · Databases

5 Essential Rules for Writing High‑Performance SQL Queries

This article presents five practical rules—return only needed rows, use proper indexes, avoid subqueries, replace OFFSET pagination with key‑based limits, and understand SQL's logical execution order—to help developers write efficient, high‑performance SQL queries across major relational databases.

IndexesQuery OptimizationSQL
0 likes · 13 min read
5 Essential Rules for Writing High‑Performance SQL Queries
ITPUB
ITPUB
Jan 3, 2021 · Databases

5 Essential Rules for Writing High‑Performance SQL Queries

This article presents five practical rules for optimizing SQL queries—including selecting only needed columns, ensuring proper indexes, avoiding subqueries, using keyset pagination instead of OFFSET, and understanding the logical execution order—along with concrete examples and execution‑plan analysis for major relational databases.

Execution PlanIndexesQuery Optimization
0 likes · 14 min read
5 Essential Rules for Writing High‑Performance SQL Queries
Top Architect
Top Architect
Dec 16, 2020 · Backend Development

Integrating PageHelper with SpringBoot and MyBatis for Efficient Pagination

This article provides a comprehensive guide on integrating PageHelper with SpringBoot and MyBatis, covering development preparation, dependency configuration, basic and advanced usage patterns, code examples, and detailed explanations of pagination mechanisms, including PageParam design and MyBatis interceptor internals.

JavaMyBatisbackend
0 likes · 19 min read
Integrating PageHelper with SpringBoot and MyBatis for Efficient Pagination
Architect
Architect
Nov 17, 2020 · Databases

MySQL Pagination Optimization Techniques and Performance Testing

The article examines MySQL pagination performance on a large order_history table, presenting various pagination methods—including simple LIMIT, subquery, ID range, and temporary table techniques—along with detailed test results that show how query speed varies with record count and offset.

Query Optimizationdatabasemysql
0 likes · 10 min read
MySQL Pagination Optimization Techniques and Performance Testing
Architecture Digest
Architecture Digest
Nov 5, 2020 · Databases

Elasticsearch Interview Question: Performance Optimization and Best Practices

The article explains how to improve Elasticsearch query speed on billions of records by leveraging filesystem cache, reducing indexed fields, using data pre‑heating, separating hot and cold indices, designing efficient document models, and applying pagination techniques such as scroll API and search_after.

Filesystem Cachebackenddata modeling
0 likes · 11 min read
Elasticsearch Interview Question: Performance Optimization and Best Practices
Top Architect
Top Architect
Oct 30, 2020 · Backend Development

Implementing Search with Redis: A Backend Development Case Study

This article demonstrates how to replace complex SQL search queries with a Redis‑based solution by caching intermediate result sets using sets and sorted sets, optimizing performance through multi‑command transactions, and adding pagination, offering a practical backend development pattern for high‑traffic e‑commerce search.

Performance OptimizationSQLSearch
0 likes · 9 min read
Implementing Search with Redis: A Backend Development Case Study
ITPUB
ITPUB
Oct 18, 2020 · Databases

Boost MySQL Pagination Speed: Practical Query Optimizations and Benchmarks

This article examines MySQL pagination on a multi‑million‑row table, compares plain LIMIT queries with subquery, ID‑range, and temporary‑table techniques, provides SQL examples and performance measurements, and offers recommendations for fast, scalable paging.

Query OptimizationSQLmysql
0 likes · 10 min read
Boost MySQL Pagination Speed: Practical Query Optimizations and Benchmarks
Top Architect
Top Architect
Oct 1, 2020 · Backend Development

Implementing Pagination in Java Web Applications with Spring MVC and MyBatis

This article demonstrates how to implement pagination and search pagination in a Java web project using Spring MVC, MyBatis, and standard pagination utilities, covering the creation of a Page utility class, MyBatis mapper configurations, DAO interfaces, service methods, controller handling, and JSP view integration.

JavaMyBatisWeb Development
0 likes · 10 min read
Implementing Pagination in Java Web Applications with Spring MVC and MyBatis
Programmer DD
Programmer DD
Sep 19, 2020 · Databases

Boost MySQL Pagination Performance: Proven Techniques and Benchmarks

This article examines various MySQL pagination strategies—including simple LIMIT clauses, sub‑query optimizations, ID‑range queries, and temporary‑table methods—by testing them on a table with millions of rows and presenting detailed timing results that reveal significant speed improvements.

LIMITQuery Optimizationmysql
0 likes · 9 min read
Boost MySQL Pagination Performance: Proven Techniques and Benchmarks
IT Architects Alliance
IT Architects Alliance
Aug 29, 2020 · Databases

Why OFFSET/LIMIT Pagination Breaks at Scale and How to Use High‑Performance Keyset Pagination

The article explains why traditional OFFSET and LIMIT pagination becomes inefficient for large tables due to full‑table scans, demonstrates the performance gap with real‑world examples, and presents keyset (cursor‑based) pagination as a fast, index‑driven alternative with practical query patterns.

Keyset PaginationOFFSET LIMITSQL
0 likes · 6 min read
Why OFFSET/LIMIT Pagination Breaks at Scale and How to Use High‑Performance Keyset Pagination
360 Quality & Efficiency
360 Quality & Efficiency
Jun 12, 2020 · Databases

MongoDB Pagination, Query Optimization, and Index Design Guide

This article explains various MongoDB pagination strategies—including skip/limit, range queries, and sorting—covers performance monitoring with profiling, details index creation and design principles, and describes how to interpret explain plans for efficient query optimization.

IndexingMongoDBQuery Optimization
0 likes · 13 min read
MongoDB Pagination, Query Optimization, and Index Design Guide
Java Backend Technology
Java Backend Technology
Apr 23, 2020 · Databases

Why MySQL LIMIT Can Reverse ORDER BY in LEFT JOIN Queries

The author discovers a puzzling MySQL bug where moving the LIMIT clause outside a nested SELECT causes the final result set to be ordered incorrectly, explains how ORDER BY inside subqueries is ignored during LEFT JOIN processing, and recommends placing ORDER BY and LIMIT at the outermost query level.

JOINLIMITOrder By
0 likes · 5 min read
Why MySQL LIMIT Can Reverse ORDER BY in LEFT JOIN Queries
Laravel Tech Community
Laravel Tech Community
Apr 15, 2020 · Backend Development

Laravel Pagination: Using Query Builder, Eloquent, Simple Pagination, and Custom Views

This guide explains how Laravel's paginator integrates with the query builder and Eloquent ORM, shows basic and simple pagination methods, demonstrates manual paginator creation, customizing URIs, appending parameters, converting results to JSON, and customizing pagination views, all with code examples compatible with Bootstrap.

Backend DevelopmentBootstrapEloquent
0 likes · 10 min read
Laravel Pagination: Using Query Builder, Eloquent, Simple Pagination, and Custom Views
Architecture Digest
Architecture Digest
Mar 26, 2020 · Databases

MySQL Pagination Optimization Techniques and Performance Testing

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.

OptimizationSQLdatabase
0 likes · 8 min read
MySQL Pagination Optimization Techniques and Performance Testing
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 6, 2019 · Backend Development

Why Your Java Service Breaks When Scaling and How to Fix It

This article examines five common Java backend pitfalls that startups face—single‑machine locking, improper multithreading, poorly defined workflows, unsafe system interactions, and non‑paginated queries—explains why they cause failures in distributed environments, and provides practical solutions such as distributed locks, message queues, state‑machine redesign, RPC interfaces, and pagination techniques.

JavaMessage QueueState Machine
0 likes · 22 min read
Why Your Java Service Breaks When Scaling and How to Fix It
Tech Musings
Tech Musings
Oct 31, 2019 · Databases

Master MySQL Tricks: Upserts, Ignoring Errors, Joins, Pagination & More

This guide explores advanced MySQL techniques—including ON DUPLICATE KEY UPDATE for upserts, INSERT IGNORE to bypass errors, replacing subqueries with JOINs, handling LEFT JOIN pitfalls, efficient pagination strategies, multi‑table UPDATE/DELETE via JOIN, and the nuances of COUNT(*) versus COUNT(1).

COUNTJOINSQL
0 likes · 12 min read
Master MySQL Tricks: Upserts, Ignoring Errors, Joins, Pagination & More
21CTO
21CTO
Jul 11, 2019 · Big Data

Boost Elasticsearch Queries on Billions of Docs: Filesystem Cache & Smart Design

Elasticsearch performance at billions‑scale can be dramatically improved by leveraging the OS filesystem cache, limiting indexed fields, separating hot and cold data, pre‑warming caches, and using scroll or search_after for pagination, while avoiding costly joins and ensuring the dataset fits in memory.

ElasticsearchFilesystem Cachedata modeling
0 likes · 12 min read
Boost Elasticsearch Queries on Billions of Docs: Filesystem Cache & Smart Design
Programmer DD
Programmer DD
Jul 2, 2019 · Databases

Why MySQL LIMIT Slows Down on Large Offsets and How to Fix It

This article analyzes why MySQL LIMIT pagination becomes increasingly slow with larger offsets, presents six optimization techniques—including using primary keys, covering indexes, prepared statements, subqueries, and composite indexes—and provides experimental results that demonstrate dramatic performance improvements.

Index OptimizationSQLmysql
0 likes · 12 min read
Why MySQL LIMIT Slows Down on Large Offsets and How to Fix It
Efficient Ops
Efficient Ops
Jun 28, 2019 · Databases

Master MySQL Optimization: 19 Practical EXPLAIN Tips and Best Practices

This guide presents nineteen essential MySQL optimization techniques—including effective use of EXPLAIN, proper handling of IN and EXISTS, avoiding SELECT *, limiting rows, optimizing ORDER BY, leveraging UNION ALL, employing full‑text indexes, and advanced join strategies—to help developers write faster, more efficient queries.

EXPLAINIndexesJOIN
0 likes · 12 min read
Master MySQL Optimization: 19 Practical EXPLAIN Tips and Best Practices
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jun 25, 2019 · Mobile Development

Master iOS Pagination: Build Custom QiPageMenuView & QiPageContentView

This article explains how to create a flexible paginated interface in iOS using the custom QiPageMenuView and QiPageContentView components, covering implementation analysis, key properties, code examples, and two usage patterns that enable decoupled menu and content views for seamless scrolling and navigation.

Objective‑CQiPageContentViewQiPageMenuView
0 likes · 10 min read
Master iOS Pagination: Build Custom QiPageMenuView & QiPageContentView
ITPUB
ITPUB
Jun 18, 2019 · Databases

Why MySQL LIMIT Pagination Slows Down and 6 Proven Optimization Techniques

This article examines why MySQL LIMIT pagination becomes slower as the offset grows, presents six practical methods—including direct LIMIT, primary‑key indexing, ordered index scans, prepared statements, sub‑queries, and joins—provides benchmark results on large tables, and distills actionable guidelines for designing covering and composite indexes to achieve fast, stable pagination.

Index OptimizationLIMITSQL
0 likes · 12 min read
Why MySQL LIMIT Pagination Slows Down and 6 Proven Optimization Techniques
Architecture Digest
Architecture Digest
May 28, 2019 · Backend Development

Improving Elasticsearch Query Performance for Billion‑Scale Datasets

To boost Elasticsearch query speed on billions of records, allocate sufficient filesystem cache memory, store only searchable fields, separate hot and cold data, warm up cache, avoid complex joins, and replace deep pagination with Scroll API or search_after for millisecond‑level responses.

ElasticsearchFilesystem Cachedata modeling
0 likes · 10 min read
Improving Elasticsearch Query Performance for Billion‑Scale Datasets
Programmer DD
Programmer DD
May 26, 2019 · Databases

How to Speed Up Large‑Scale MySQL Pagination: Practical Tips & Benchmarks

This article explains why traditional MySQL pagination (ORDER BY … LIMIT N,M) becomes painfully slow on tens of millions of rows, analyzes the root causes, and presents concrete optimizations such as covering‑index delayed joins, bookmark‑based scans, and query rewrites that can cut execution time to a third of the original.

Bookmark ScanCovering IndexQuery Optimization
0 likes · 9 min read
How to Speed Up Large‑Scale MySQL Pagination: Practical Tips & Benchmarks
dbaplus Community
dbaplus Community
May 21, 2019 · Big Data

How to Supercharge Elasticsearch Queries on Billions of Records

This article explains why Elasticsearch can be slow on massive datasets, then details practical techniques—leveraging filesystem cache, pre‑heating hot data, separating hot and cold indices, designing lean document models, and avoiding deep pagination—to achieve sub‑second query performance at billions‑scale.

Big DataElasticsearchdata modeling
0 likes · 11 min read
How to Supercharge Elasticsearch Queries on Billions of Records