This tutorial walks through configuring MyBatis with XML for database operations, covering Maven dependencies, project structure, core configuration files, mapper interfaces, dynamic SQL, and JUnit testing with a complete employee CRUD example.
This MongoDB cheat sheet guides SQL developers through the mindset shift to NoSQL, covering concept mappings, CRUD operations, indexing, aggregation pipelines, and execution plan analysis with practical code examples for each operation and key pitfalls to avoid.
This tutorial builds a task manager with FastHTML, MongoDB, Pydantic, and HTMX, demonstrating async CRUD operations, partial HTML updates via HTMX, and clarifying the difference between request-driven partial refreshes and true multi-client real-time synchronization requiring MongoDB Change Streams and WebSockets.
Manually creating entity classes, CRUD interfaces and SQL for dozens of tables can consume dozens of hours, so the author built an open‑source tool that automatically generates the full backend stack—from table definition to Java models, MyBatis mappers, services and controllers—dramatically accelerating development.
The article explains how MybatisPlus Pro extends MybatisPlus to eliminate repetitive Service and Controller code, provides a ready‑to‑use BaseController, automatic QueryWrapper generation, and deepens the understanding of its dynamic proxy, interceptor chain and SQL injection mechanisms, while also outlining its strengths, limitations, suitable scenarios and common pitfalls.
This article provides a comprehensive, step‑by‑step reference of essential MySQL commands—including connection, database and table creation, data manipulation, schema alteration, and query optimization with EXPLAIN—complete with code examples, parameter explanations, and performance warnings for safe production use.
MyBatisPlus Pro extends MyBatisPlus by providing a BaseController that auto‑generates CRUD, pagination, and conditional queries, dramatically cutting repetitive code; the article walks through its architecture, quick‑start steps, deep technical mechanisms, pros and cons, and practical usage guidelines.
This article analyzes MybatisPlus Pro, explaining how it eliminates repetitive CRUD code in MyBatis‑Plus projects by providing a BaseController and utility classes that auto‑generate service and controller layers, while also detailing its internal mechanisms, advantages, drawbacks, suitable scenarios, and common pitfalls.
The article shows how repetitive CRUD code in Gin can be refactored with Go 1.18 generics by defining a Creatable interface, writing a single generic CreateHandler, using factory functions and type constraints, and registering routes in one line, resulting in zero duplicate code and clearer responsibilities.
This article introduces MyBatisPlus Pro, walks through adding the MyBatisPlus dependency, creating a utility class, defining a generic BaseController with full CRUD, pagination support, and shows how to extend it in specific controllers, providing a ready‑to‑use RESTful API template.
The article demonstrates how to eliminate repetitive CRUD code in FastAPI projects by creating a type‑safe, generic repository using Python generics and SQLAlchemy, showing a concrete abstract base class, concrete implementations, custom filters, error handling, and real‑world metrics that cut repository code from hundreds to a few dozen lines.
This tutorial walks through integrating SpringBoot with JPA (Hibernate) from adding dependencies to configuring the datasource, defining entities, using JpaRepository, building service and controller layers, applying method‑naming rules, writing custom queries, comparing JPA with MyBatis and JdbcTemplate, and highlighting key pitfalls for rapid, low‑boilerplate data‑access development.
This article walks through a full SpringBoot‑MyBatis integration, covering Maven dependencies, application.yml configuration, database schema, entity definition, mapper XML, service layer with transactions and pagination, REST controller endpoints, key features, and common pitfalls.
This tutorial shows how to use the Java‑based magic‑api framework to generate Spring Boot HTTP endpoints directly from a UI, covering dependency setup, datasource configuration, database preparation, CRUD scripts, validation, result mapping, transaction handling, and Swagger integration.
This guide walks through installing magic-api in a SpringBoot project, configuring data sources, creating CRUD endpoints with magic-script, adding validation, transaction handling, and integrating Swagger for API documentation, complete with code snippets and configuration examples.
This step‑by‑step guide shows how to use the Go‑Kratos microservice framework to create a clean‑architecture user service, covering environment setup, project scaffolding, Protobuf API definition, code generation, layered implementation (biz, data, service), server registration, and testing with curl.
This guide shows how to use the Java‑based magic‑api framework to generate CRUD REST endpoints directly from a UI, covering Maven setup, datasource configuration, script‑based request handling, validation, result mapping, transactions, and Swagger integration.
This tutorial explains SQL fundamentals including CRUD operations, the difference between SELECT * and explicit columns, table and column aliases, INNER/LEFT/RIGHT JOIN types with practical examples, and the SQL execution order (FROM/JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT) using a cooking analogy, plus beginner tips.
This guide presents a comprehensive collection of MySQL commands covering database management, table creation and alteration, CRUD operations, index handling, transaction control, and essential administration queries, providing clear examples for each task.
This article presents a step‑by‑step learning roadmap for the domestic INFINI Easysearch engine, covering five stages—from basic concepts and environment setup to advanced search features, performance tuning, security hardening, and real‑world production deployment—so readers can become proficient within a few months.
This tutorial walks you through setting up a Laravel development environment, creating a database, generating models, migrations, controllers, Blade views, defining routes, and testing a complete CRUD task manager, with optional extensions and troubleshooting tips.
This tutorial walks you through integrating MyBatis-Plus with Spring Boot, covering environment preparation, Maven dependencies, configuration of data sources, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing with a REST controller.
Learn how to connect to MongoDB using PyMongo, create databases and collections, and perform essential CRUD operations—including inserting single or multiple documents, querying with filters and regex, updating records with update_one and update_many, counting, sorting, pagination, and deleting—complete with Python code examples.
This tutorial walks through installing MongoDB and PyMongo, establishing a connection, selecting databases and collections, and demonstrates how to insert, query, count, sort, skip, limit, update, and delete documents using both legacy and modern PyMongo methods, complete with code examples and operator references.
This article explains MySQL’s native JSON data type introduced in 5.7, covering its binary storage format, built‑in functions, generated‑column indexing, performance advantages over string storage, and detailed CRUD examples with SQL syntax and practical code snippets.
The article introduces a self‑built utility that automatically generates Java backend code—including entity classes, DAO interfaces, service implementations, and controllers—based on database table definitions, dramatically reducing the manual effort of creating dozens of tables and their associated CRUD logic.
This guide walks through adding MyBatis-Plus to a Spring Boot project, configuring basic settings, using CRUD operations, condition builders, pagination, advanced features like auto‑fill, logical delete, optimistic locking, code generation, common pitfalls, and practical recommendations for effective usage.
This article introduces the EasyCode IntelliJ plugin, explains how it generates CRUD code for Java projects using custom Velocity templates, walks through installation and configuration steps with screenshots, and shows the necessary Spring Boot adjustments to get a fully functional backend up and running.
This article walks through building a reusable BaseController using MyBatisPlusPro in a Spring Boot application, covering dependency setup, utility methods for query conversion, generic CRUD endpoints, pagination configuration, and how to extend the controller for specific entities, providing ready‑to‑use code snippets for each step.
This article shares practical strategies for optimizing MyBatis‑Plus CRUD operations in massive‑data scenarios, covering query, insert, update, delete, batch processing, and database‑level tuning to keep performance stable when tables exceed ten million rows.
This article introduces MyBatis-Plus, explains its core zero‑invasion features such as effortless single‑table CRUD, powerful Lambda condition builders, and a rich plugin system, then provides practical guidelines and code examples for building secure, high‑performance DAO layers in microservice back‑ends.
This tutorial walks you through creating a reusable BaseController in Spring Boot using MyBatis‑Plus, introducing a utility class for dynamic query building, configuring pagination support, and extending the controller for any entity to instantly gain full CRUD, list, pagination, sorting, and count operations.
This article walks through creating a reusable MyBatisPlus‑based controller framework for Spring Boot, covering dependency setup, utility methods for query building and reflection, a generic BaseController with full CRUD endpoints, pagination configuration, and concrete controller extensions, enabling rapid development of RESTful APIs.
This article introduces MyBatis-Plus as a zero‑intrusion enhancement to MyBatis, explains its core values of convenience, safety, and compatibility, details CRUD methods, condition builders, plugin mechanisms, and best‑practice guidelines for building efficient, secure backend services.
This article introduces MyBatis-Plus, explains its core zero‑injection CRUD capabilities, demonstrates powerful condition builders, plugin extensions, and best practices for secure, efficient data access, including custom query objects, micro‑service integration, and advanced mapper customization, helping developers boost backend productivity.
This guide walks you through the core MongoDB commands—including creating and switching databases, listing databases, inserting, updating, querying (with filters, pagination, distinct, and fuzzy search), counting records, and deleting documents—providing concise examples for each operation.
This comprehensive guide walks you through MySQL fundamentals and advanced features, covering database architecture, storage engines, data types, CRUD operations, complex queries, transactions, indexing, performance tuning, replication, JSON handling, full‑text search, and best practices for security and backup.
This guide walks you through using JetBrains DataGrip on AlmaLinux to connect to a PostgreSQL server, then demonstrates step‑by‑step how to insert, modify, and delete records via the graphical interface and optional SQL console, highlighting key settings and safety tips.
This tutorial introduces the magic‑api Java framework, shows how to integrate it with Spring Boot, configure data sources, create the necessary MySQL tables, and implement full CRUD operations, parameter validation, result transformation, transaction handling, and Swagger documentation using concise scripts.
This article introduces MybatisPlusPro, an extension of MyBatis‑Plus that automates controller‑level CRUD, pagination, dynamic queries, data auditing, permission control, and performance optimizations, showing how developers can dramatically reduce code and improve efficiency in Java backend projects.
This tutorial shows how to extend MyBatis‑Plus functionality to the controller layer by creating a reusable BaseController, utility methods, pagination configuration, and concrete controllers, enabling full CRUD, list, page, and count operations with minimal code.
This tutorial walks through Peewee’s lightweight ORM features—from creating, bulk inserting, updating, and deleting records to complex aggregations, window functions, CTEs, and PostgreSQL RETURNING clauses—while comparing its learning curve and performance to SQLAlchemy using real‑world Leapcell examples.
Learn essential MySQL commands—from connecting and managing databases, tables, and users to performing CRUD operations, advanced queries, indexing, and backup/restore—along with practical code examples and optimization tips, enabling you to efficiently handle relational data in real‑world applications.
A comprehensive step‑by‑step tutorial shows how to integrate MyBatis‑Plus into a Spring Boot project, covering dependencies, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing.
This tutorial shows how Java developers can use the magic‑api framework to rapidly create Spring Boot CRUD APIs without writing Controllers, Services, or DAOs, covering Maven setup, configuration, database schema, code‑free endpoint design, validation, transactions, Swagger integration, and deployment.
This tutorial walks you through setting up a Go environment, initializing a project, and using the high‑performance Gin framework to create a complete RESTful API with CRUD operations, middleware for logging and authentication, error handling, project structure optimization, and deployment best practices.
This article walks you through creating a reusable BaseController using MyBatisPlusPro, including dependency setup, utility methods for reflection, a generic CRUD controller, pagination configuration, and how to extend it in your own Spring Boot applications.
This tutorial shows how to create a reusable BaseController in a Spring Boot application using MyBatis‑Plus, providing generic CRUD, list, pagination, and count endpoints for any entity while demonstrating utility methods, pagination configuration, and concrete controller extensions.
This tutorial walks through creating a generic BaseController that provides CRUD, list, pagination, and count operations for any entity by adding MyBatis‑Plus, writing a utility class for query building, configuring a pagination interceptor, and extending the base class in concrete controllers, all illustrated with complete Java code snippets.
This tutorial shows how to extend MyBatisPlus with a reusable BaseController, create utility methods for naming conversion and query building, configure pagination support, and quickly generate CRUD REST endpoints in Spring Boot projects using MyBatisPlusPro.
This guide shows how to use Tencent's open‑source APIJSON library with a Spring Boot demo to automatically generate full‑stack CRUD REST endpoints from database tables, covering project setup, configuration, table creation, and example requests for querying, adding, updating, deleting, and paginating product brand data.
This guide shows how to create a reusable BaseController using MyBatis‑Plus, reflection utilities, and Spring Boot annotations to provide automatic CRUD, list, pagination and count endpoints for any entity with minimal code.
This article demonstrates how to automate CRUD functionality in a Spring Boot application by adding MyBatisPlus, creating utility methods for query building and reflection, implementing a generic BaseController, configuring pagination support, and extending the controller for specific entities, providing a reusable RESTful API template.
This tutorial demonstrates how to create a complete meeting‑management CRUD application using Spring Boot 3, Spring AI Tools, and a custom ChatClient, covering environment setup, entity definitions, repository, service layer, tool integration, and REST endpoints with code examples and screenshots.
This tutorial demonstrates how to configure Spring 6 with JdbcTemplate, create a MySQL database and table, define entity and datasource beans, and perform CRUD operations—including batch updates and callback functions—while also showing integration with the Druid connection pool.
This article presents a step‑by‑step tutorial for building a Python Tkinter vaccine management application that demonstrates practical CRUD operations, GUI design, and MySQL database integration, providing complete source code, database schema, and detailed explanations for each functional module.
This article introduces APIJSON, a zero‑code JSON‑based ORM for APIs, outlines its key features, and provides a step‑by‑step Spring Boot 3 demo—including cloning the repository, configuring the database, and performing full CRUD operations via Postman with code examples.
This article presents a simple basketball information management system built with Django, detailing CRUD operations for player data, pagination logic, and corresponding HTML templates for both admin and front‑end interfaces, accompanied by full source code snippets and screenshots of the resulting pages.
This guide walks you through using the Tongyi Lingma AI coding assistant to quickly create a personal note‑taking website with full CRUD functionality, covering preparation, environment setup, step‑by‑step code generation, feature expansion, common pitfalls, and iterative refinement for front‑end developers.
This article demonstrates how to create a Python MySQLWrapper class that encapsulates connection handling, query execution, and CRUD operations, providing a modular, reusable interface for interacting with MySQL databases, complete with example code and usage instructions.
The article demonstrates how to refactor a large PHP API suite into a Java Spring MVC application by creating a generic AggregateController that, through model‑name mapping, reflection‑based repository registration and a thread‑safe MappingKit, provides CRUD endpoints for any table, collapsing hundreds of endpoints into just two controllers for client and admin.
This article introduces ten common Python database interaction patterns—from basic CRUD operations and table creation to advanced transaction handling, batch inserts, and stored procedures—culminating in a complete user‑registration system example that demonstrates how to combine these techniques effectively.
MyBatis-Plus, an enhanced toolkit for MyBatis, simplifies CRUD operations and injects dynamic SQL, and this release introduces numerous bug fixes, new annotations, code‑generator enhancements, and upgrades to MyBatis, Spring Boot, and Kotlin, with important migration notes for developers.
This tutorial introduces pandas' two core data objects—Series and DataFrame—demonstrates how to create, index, query, modify, add, delete, sort, merge, and copy them, and shows common parameters, functions, I/O operations, plotting, and a practical log‑analysis example using Python.
This article demonstrates how to store SQL queries in .ini files and use Python's mysql-connector-python library together with configparser and logging to perform MySQL CRUD operations, providing full code examples and explanations for configuration, connection handling, query execution, and log management.
This article introduces MyBatis-Plus, an enhancement library for MyBatis, outlines its major advantages, explains performance‑analysis and advanced plugins, and provides a step‑by‑step tutorial with code examples for integrating, configuring, and using the framework in Java Spring Boot projects.
This article walks through step‑by‑step how to create a simple CRUD service using Go's Gin framework with Gorm and MySQL, then shows the equivalent implementation with Java Spring Boot, MyBatis‑Plus and MySQL, comparing the two approaches and providing complete source code.
This article introduces an open‑source tool that automatically generates all Java business code—including entity classes, DAO interfaces, SQL statements, service implementations, and controllers—for new database tables, dramatically reducing the hours spent on repetitive CRUD scaffolding.
This article introduces a Spring Boot code‑generation tool that automatically creates database tables, entity classes, DAO interfaces, service layers and controllers, turning weeks of manual CRUD development for dozens of tables into a matter of minutes, and explains its design, templates, dynamic parameters and usage.
This article introduces a lightweight IntelliJ IDEA plugin that automatically generates database‑related Java code—including entities, DTOs, controllers, and service layers—based on a simple configuration file, while also offering design‑pattern template generation to accelerate backend development.
This article explains how APIJSON can replace dozens of traditional SpringBoot controller methods with a single configurable endpoint, demonstrating concise request formats, permission annotations, and example code for creating, reading, updating, deleting, and aggregating data in a Java backend.
This article explains how APIJSON lets developers replace dozens of SpringBoot CRUD endpoints with a single, configurable interface for GET, POST, PUT, DELETE and HEAD requests, dramatically cutting code lines while supporting complex queries, pagination, joins and role‑based permissions.
The article introduces Fluent Mybatis, a compile‑time code‑generating ORM that merges Mybatis‑Plus, Dynamic SQL and JPA features, eliminates XML mappers, offers a fluent, type‑safe Java API, and demonstrates through concise examples how it reduces boilerplate compared with native Mybatis and Mybatis‑Plus.
This article demonstrates how to encapsulate MySQL operations in a Python MySQLWrapper class, providing modular methods for connecting, querying, inserting, updating, and deleting records, along with a complete example and usage instructions.
This tutorial demonstrates essential Python list operations, covering case‑sensitive and case‑insensitive sorting, reverse ordering, iteration with for and while loops, element removal by value or index, clearing, appending, inserting, extending, item modification, slicing, indexing, length checking, and mixed‑type lists, all illustrated with clear code examples.
This tutorial guides beginners through creating a complete user registration and login system using PHP for the backend, MySQL for data storage, and HTML, CSS, and vanilla JavaScript for the frontend, covering environment setup, database creation, form design, server‑side logic, and basic client‑side validation.
This comprehensive guide walks you through MongoDB fundamentals, installation checks, service management, user authentication, database and collection creation, and essential CRUD commands, providing clear examples and code snippets to help you efficiently manage and query your NoSQL data.
This article explains how to choose between fine‑grained and coarse‑grained resource designs in REST APIs, illustrating trade‑offs with blog‑post examples, showing how to model business processes as intent resources, and discussing the impact of avoiding PUT in favor of CQRS.
This article provides 10 detailed Python code examples demonstrating how to connect to, query, insert, update, delete, and manage MySQL databases with proper error handling and resource management.
This guide demonstrates how to create a simple Go web API using the Gin framework, define a recipe data model, implement CRUD endpoints backed by MongoDB, add Redis caching for list queries, and provide a complete runnable example with testing scripts.
This guide introduces Medoo, a lightweight PHP database framework built on PDO, outlines its key features, shows installation via Composer, demonstrates basic CRUD operations, and explains integration with the Webman framework, including multi‑database configuration and usage examples.
This tutorial walks through creating a full‑stack project that uses json-server to expose a RESTful API, demonstrates CRUD operations via Postman, and shows how to interact with the API from a simple frontend using JavaScript fetch calls.
This article introduces a self‑built tool that automatically generates database, service, DAO, and controller code for CRUD operations based on table definitions, explains its underlying template‑and‑parameter mechanism, demonstrates usage with a sample product table, and provides customizable templates and dynamic parameters for extensibility.
Learn how to create a simple, high‑performance Rust microservice using Actix‑web, Serde, and SQLite, covering environment setup, project structure, core code for CRUD operations, and testing commands, while highlighting Rust’s memory safety, speed, and low runtime overhead.
This tutorial explains how to install the MongoDB server, add the PHP MongoDB extension, configure Laravel to connect to MongoDB, and implement full CRUD operations using a custom Eloquent model and controller.
This article walks developers through the fundamentals of designing robust e‑commerce APIs, covering CRUD operations, protocol choices such as REST, GraphQL and gRPC, versioning strategies, rate limiting, CORS, and best practices for request idempotency and backward compatibility.
This guide walks through implementing a complete product management module in a Java e‑commerce system, covering Snowflake distributed ID generation, database schema design for SPU and SKU tables, CRUD operations, category‑brand linking, audit workflow, status toggling, batch processing, and logical deletion, all with concrete code examples.
The article presents a technique that uses a generic AggregateController, dynamic model‑name routing, and a lightweight mapping container to share CRUD logic across dozens of tables, reducing hundreds of API methods to just two controllers while keeping the codebase clean and extensible.
This tutorial walks you through using PHP's SQLite3 extension to install the driver, connect to a file‑based SQLite database, create tables, and execute full CRUD operations—including inserting, querying, updating, and deleting records—plus closing the connection and viewing data with an IDE.
This tutorial introduces the EasyCode IntelliJ IDEA plugin, explains how to install it, connect a database, configure generation settings, and automatically produce Java CRUD components such as entities, DAOs, services, and controllers, concluding with integration steps in a Spring Boot application.
This guide introduces Strapi, an open‑source headless CMS, covering its key features, quick installation, language switching, basic usage for creating content types, exposing RESTful and GraphQL CRUD APIs, visualizing data with external tools, and migrating SQLite databases to other systems.
Discover how the low‑code Java framework Erupt enables rapid creation of full‑stack admin applications without writing front‑end code, by using annotations to generate CRUD pages, integrating with SpringBoot, configuring dependencies, and extending with modules for scheduling, code generation, monitoring, NoSQL, and magic‑API.
This guide walks through integrating Spring Data Elasticsearch into a Spring Boot application, covering entity mapping annotations, repository creation, service layer implementation, and unit tests to perform create, read, update, delete, and fuzzy search operations on Elasticsearch indices.
Learn how to seamlessly integrate Spring Data Redis Repositories in a Spring Boot 2.7 environment, covering object mapping, CRUD operations, indexing with @Indexed, query‑by‑example, batch saves, and setting expiration using @TimeToLive, complete with code examples and visual data representations.
This article explains how Spring Data REST automatically exposes Spring Data repositories as RESTful endpoints, covering setup, entity and repository definitions, exposure strategies, custom base paths, CRUD operations, field projection, event handling, and visual tools for Spring Boot 3.0.5 with JDK 17.
The author recounts a two‑year journey as a Java developer, describing experiences across three companies, the challenges of CRUD‑focused work, the need to learn front‑end skills, and insights on balancing technical growth with business understanding in both large and small firms.
This tutorial demonstrates how to automate CRUD functionality in a Spring Boot application by introducing MyBatisPlus, creating a reusable utility class, configuring pagination, and implementing a generic BaseController that can be extended by concrete controllers for any entity.
This guide walks through integrating MyBatis‑Plus with Spring Boot, covering dependency setup, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑data‑source support, and testing with concrete code examples and detailed explanations.