DDDD

Author: sathishk

content/docs/why/_index.md

@@ -20,4 +20,8 @@ seo:
   noindex: false # false (default) or true
 ---
 
-SQL Compomnents is a compile time **ORM** that build native JDBC Code out of Relationsal database instance. It also provides type safe SQL Builder for safer, secure and productive persdiatnce development.
+SQL Compomnents is a compile time tool that build native JDBC Code out of Relationsal database instance. It also provides type safe SQL Builder for safer, secure and productive persdiatnce development. Before we see how it is diffrent from others , We should understand what all we should do when we interact with relational databases from java.
+
+Connection Management
+Model
+Data Access Object

content/docs/why/jpa.md

@@ -15,54 +15,20 @@ seo:
 ---
 
 
-## Comparison with JPA (Java Persistence API)
+JPA will abstract all the connection management and also Dao complexity from the user. For E.g while we use Spring JPA , We should will have below item
 
-### 1. Query Handling
-- **JPA**: In JPA, the framework abstracts away the SQL queries by using JPQL (Java Persistence Query Language) or a Criteria API. This simplifies the developer's work by automating the generation of SQL queries, reducing the amount of boilerplate code.
-- **mysqlComponents**: In contrast, `mysqlComponents` directly uses Java's native libraries for query execution. Developers have full control over the SQL queries, which provides flexibility for complex or performance-critical queries. 
+All you will write is 
 
-### 2. Learning Curve
-- **JPA**: With its abstraction, JPA has a steeper learning curve due to the complexity of the framework, annotations, entity management, and the need to understand the JPA lifecycle.
-- **mysqlComponents**: Since it relies on Java’s native libraries and requires developers to write SQL directly, `mysqlComponents` is straightforward for those already familiar with SQL, resulting in a flatter learning curve.
+Model Classes
+Data Access Objects ( Only Interface )
 
-### 3. Control Over SQL
-- **JPA**: JPA generates SQL queries based on object mappings, which may not always be optimal or well-suited for complex queries. Custom queries are possible, but using native SQL within JPA breaks its abstraction and might complicate code maintenance.
-- **mysqlComponents**: Developers have complete control over the SQL syntax and logic, which can lead to more optimized and tailored queries.
 
----
-
-## Advantages and Disadvantages of JPA
-
-### Advantages of JPA:
-1. **Abstraction**: Simplifies interaction with databases by abstracting the SQL layer, allowing developers to focus on the business logic.
-2. **Entity Management**: Automates the persistence lifecycle, including transactions, caching, and object-relational mapping (ORM), leading to less boilerplate code.
-3. **Cross-Database Support**: JPA is database-agnostic, making it easier to switch databases without rewriting queries.
-
-### Disadvantages of JPA:
-1. **Performance Overhead**: The abstraction adds a performance overhead, especially for complex queries. The generated SQL may not always be optimized.
-2. **Learning Complexity**: JPA requires a good understanding of ORM concepts, annotations, and persistence lifecycle, which increases the learning curve.
-3. **Lack of Flexibility**: Complex queries are harder to write and manage within the JPA framework. Sometimes, developers need to use native SQL, negating the benefit of the abstraction.
-
----
-
-## Advantages and Disadvantages of `mysqlComponents`
-
-### Advantages of `mysqlComponents`:
-1. **Full SQL Control**: Developers write and execute native SQL queries directly, allowing for better performance and optimization for specific use cases.
-2. **Simplicity**: There’s no need to learn an ORM or abstraction layer, making the library easier for developers familiar with SQL and Java.
-3. **Lightweight**: No additional ORM overhead means better performance, especially for applications with complex query requirements.
-
-### Disadvantages of `mysqlComponents`:
-1. **Manual Query Management**: Since there’s no abstraction, developers must manage SQL queries, transactions, and entity mapping manually, increasing the potential for errors and requiring more effort.
-2. **Database-Specific**: SQL queries are specific to the database being used, which can limit cross-database portability unless developers account for different SQL dialects.
-3. **No Caching**: Unlike JPA, which provides caching mechanisms, `mysqlComponents` doesn’t handle caching natively, so developers must implement caching on their own if needed.
-
----
-
-## Conclusion
-
-`mysqlComponents` is a robust alternative for developers who prefer fine-grained control over their SQL queries. While JPA is ideal for projects where abstraction and ease of use are critical, `mysqlComponents` excels in performance-sensitive applications where developers require full control over SQL execution.
+```java
+```
 
-Each framework has its strengths and weaknesses, and choosing between JPA and `mysqlComponents` depends on the specific needs of your application, such as performance, complexity, and developer expertise.
+SQL Components will do the same functionality with better typesafe API.
 
+```java
+```
 
+where Model, Data Access Objects Interfaces will be automatically generated.

content/docs/why/sql-builders.md

@@ -14,6 +14,21 @@ seo:
   noindex: false # false (default) or true
 ---
 
+SQL Builders will abstract all the connectiona management complexity from the user. For E.g while we use Spring JDBC Client, We should will have below item
 
-Spring JDBC Template
+All you will write is 
+
+Model Classes
+Data Access Objects ( Using JDBC Clients )
+RowMappers
+
+```java
+```
+
+SQL Components will do the same functionality with better typesafe API.
+
+```java
+```
+
+where Model, Data Access Objects and RowMappers will be automatically generated.
 

hugo_stats.json

@@ -20,7 +20,6 @@
       "h1",
       "h2",
       "h3",
-      "h4",
       "h5",
       "head",
       "header",
@@ -266,18 +265,12 @@
       "comparison-with-jooq-framework",
       "comparison-with-jpa-java-persistence-api",
       "conclusion",
-      "custom-code-generation",
       "disadvantages-of-jooq",
       "disadvantages-of-jpa",
       "disadvantages-of-mysqlcomponents",
       "disadvantages-of-sqlcomponents",
       "doks-docs-nav",
-      "expand-the-frameworks-compatibility-to-include-oracle-and-sql-server-enabling-seamless-integration-with-a-broader-range-of-database-systems",
       "further-reading",
-      "geo-location-datatypes-support",
-      "implement-custom-code-generation-features-to-automate-and-standardize-repetitive-coding-tasks-enhancing-productivity-and-reducing-manual-errors",
-      "integrate-transaction-support-to-ensure-data-consistency-and-reliability-during-complex-operations-by-managing-and-safeguarding-multiple-changes-within-a-single-transaction",
-      "introduce-support-for-geo-location-data-types-allowing-the-handling-and-processing-of-spatial-data-directly-within-the-framework",
       "key-differences",
       "offcanvasNavMain",
       "offcanvasNavSection",
@@ -290,9 +283,7 @@
       "searchToggleDesktop",
       "searchToggleMobile",
       "socialMenu",
-      "support-for-oracle-and-sql-server",
       "toc",
-      "transaction-support",
       "what-is-jooq"
     ]
   }