Executing SQL Statements with Java Statement Interface

📆 Day 246 & 247 of 365 days Spent time strengthening fundamentals in Java, MySQL, and JDBC. Worked on understanding how Java applications connect to databases, execute queries, and handle data using JDBC. Covered basics like connections, statements, and simple CRUD operations while reinforcing SQL concepts alongside. This is a key step toward building real-world backend applications, where code actually interacts with data 🚀 #Java #MySQL #JDBC #BackendDevelopment #Database #SoftwareEngineering #Developers #BuildInPublic #CodingJourney #Tech

🗄️ Database Optimization is a Game Changer Earlier, I focused only on Java code. But real performance issues often come from DB. Lessons I learned: ✔ Avoid unnecessary queries ✔ Use indexes wisely ✔ Don’t fetch everything 👉 Backend performance = Code + Database Ignoring DB = slow applications. Do you spend time optimizing queries? #SQL #BackendDevelopment #Java

🚀 Callable Statements for Stored Procedures (Java) The `CallableStatement` interface is used to execute stored procedures in the database. Stored procedures are precompiled SQL code stored within the database. `CallableStatement` allows you to pass input parameters to the stored procedure and retrieve output parameters. Using stored procedures can improve performance and security by encapsulating complex database logic. This also reduces network traffic between the application and the database. #Java #JavaDev #OOP #Backend #professional #career #development

🚀 Floating-Point Data Types: float and double (Java) Java offers two floating-point data types: `float` (32 bits, single-precision) and `double` (64 bits, double-precision). `double` provides higher precision and a wider range than `float`. By default, floating-point literals are treated as `double`. You should use `float` when memory is a concern and the required precision is lower. Use `double` for most general-purpose floating-point calculations where higher precision is needed. Learn more on our app: https://lnkd.in/gefySfsc #Java #JavaDev #OOP #Backend #professional #career #development

🚀 Project Update: Java Authentication System with MySQL Integration Excited to share an upgrade to my User Authentication System — now fully integrated with MySQL using JDBC! 💻🔐 What started as a console-based Java project has now evolved into a more realistic authentication system with data persistence and database-backed logic. 💡 Code-Level Improvements I Worked On: - Refactored code to shift from in-memory storage → database-driven logic - Added methods like: - "saveToDatabase()" for inserting users - "loadFromDatabase()" to fetch existing users - "updateLoginStatus()" to sync login attempts and lock status - Used PreparedStatement for secure and efficient queries - Handled edge cases using custom exceptions (WeakPasswordException, AccountLockedException) 📊 This project helped me understand how real-world authentication systems work beyond just logic — including persistence, error handling, and database design (3NF structured table) 🔗 GitHub repo: https://lnkd.in/dUd8bstw Would love your feedback! 🙌 #Java #MySQL #JDBC #Authentication #BackendDevelopment #LearningInPublic

I've been revisiting some #Java code I wrote years ago, now using #ClaudeCode to fix some bugs, and add some enhancements. Using #Claude in a terminal inside of #NetBeans is a perfect way to do this. The code I'm working on is a Java no-heap #database, which stores its data in an area of memory outside of the Java heap, but also with optional write-through to persistent storage. I tested it with a large number of very large records, almost 6GB in size, asking it how much Java Heap was consumed. Below is what Claude had to say. It's working perfectly. Next steps are to make it multi-modal and add #NoSQL and #GraphDB functionality to it. In fact, I've already paired with Claude to generate a design and a plan to do this after some foundational performance enhancements are complete.                       ● Let me run it with a deliberately tiny heap to prove the point:                                                                                            ● Bash(cd NoHeapDBTest && mvn exec:java                                 -Dexec.mainClass="noheapdbtest.NoHeapDBTest" -Dexec.jvmArgs="-Xmx32m -verbose:gc"…)        ⎿ [INFO] Scanning for projects...                                                [INFO]                                                            [INFO] -----------------< NoHeapDBTest >------------------    … +30 lines (ctrl+o to expand)                                              ⎿ (timeout 2m)                                                                                      ● That tells the story perfectly. The JVM is running the entire test — allocating billions of bytes of data — with only  32 MB of heap, and there's not a single GC log line printed. Zero garbage collections. The heap is essentially idle.                                                                  All the data (5.4 GB of records + the growing index) lives entirely in direct memory. The heap only holds the thin Java  objects — the NoHeapDB instance, the FixedHash instance, a few ByteBuffer wrapper objects, loop variables. That's a  few hundred kilobytes at most.                                                                               This is exactly what NoHeapDB is designed to do: store arbitrary amounts of data with zero heap footprint and zero GC impact, regardless of dataset size.

🚀 Understanding the N+1 Problem in Spring Boot If you're working with Spring Boot and Hibernate, chances are you've faced performance issues without realizing the root cause. 🔍 What happens? * 1 query fetches parent data * N additional queries fetch child data * Result = 1 + N queries (bad for performance!) ⚠️ Why it matters? * Slower APIs * High database load * Poor scalability in microservices & banking systems ✅ How to fix it? * Use JOIN FETCH * Apply @EntityGraph * Enable batch fetching * Use DTO projections 💡 Optimizing database queries is critical for building high-performance, scalable applications. 📌 Small improvements in query design can lead to massive performance gains in production systems. #SpringBoot #Hibernate #Java #Microservices #BackendDevelopment #PerformanceOptimization #JPA #SoftwareEngineering #TechTips #Coding #Developers #Database #Scalability #QaisarAbbas #Linkedin

💻 JDBC in Java — Connecting Code with Databases 🚀 Every backend application needs to store, retrieve, and manage data — that’s where JDBC (Java Database Connectivity) comes in 🔥 This visual breaks down the complete JDBC flow with a practical example 👇 🧠 What is JDBC? JDBC is a Java API that allows applications to connect and interact with databases. 👉 It acts as a bridge between Java application ↔ Database 🔄 JDBC Workflow (Step-by-Step): 1️⃣ Load & Register Driver 2️⃣ Establish Connection 3️⃣ Create Statement 4️⃣ Execute Query 5️⃣ Process Result 6️⃣ Close Connection 🔍 Core Components: ✔ DriverManager → Manages database drivers ✔ Connection → Establishes connection ✔ Statement → Executes SQL queries ✔ PreparedStatement → Parameterized queries (secure 🔐) ✔ ResultSet → Holds query results ⚡ Basic Example: Connection con = DriverManager.getConnection(url, user, pass); PreparedStatement ps = con.prepareStatement( "SELECT * FROM students WHERE id = ?" ); ps.setInt(1, 1); ResultSet rs = ps.executeQuery(); while(rs.next()) { System.out.println(rs.getString("name")); } 🚀 Types of JDBC Drivers: Type 1 → JDBC-ODBC Bridge Type 2 → Native API Type 3 → Network Protocol Type 4 → Thin Driver (Most used ✅) 💡 Why use PreparedStatement? ✔ Prevents SQL Injection ✔ Improves performance ✔ Safer for dynamic queries ⚠️ Best Practices: ✔ Always close resources (Connection, Statement, ResultSet) ✔ Use try-with-resources ✔ Handle exceptions properly ✔ Prefer PreparedStatement over Statement 🎯 Key takeaway: JDBC is not just about running queries — it’s the foundation of how Java applications communicate with databases efficiently and securely. #Java #JDBC #Database #BackendDevelopment #Programming #SoftwareEngineering #Coding #100DaysOfCode #Learning

🗄️ Most Developers Ignore This… And Regret Later Backend performance is not only about Java code. 👉 It’s about SQL. I learned this the hard way: ✔ Slow queries = slow application ✔ Missing indexes = performance issues ✔ Fetching unnecessary data = waste 💡 Good developer = Good with database too. Do you optimize your queries? 🤔 #SQL #Backend #Java #Performance

🚀 Java Streams in Action: Partitioning Data ! 👉 Partition employees into two groups - one earning above ₹50,000 and the others. i. Have you ever needed to split data into two groups based on a condition? ii. Here’s a simple example using Java Streams to partition employees based on salary. 🔍 Approach 👉 stream() Converts the list into a stream to perform functional-style operations. 👉 filter(Objects::nonNull) Removes any null objects from the list to avoid NullPointerException. 👉 collect(...) Terminal operation that transforms the stream into a collection (in this case, a Map). 👉 Collectors.partitioningBy(...) This is the key part 🔥 It splits the data into two groups based on a condition: true -> Employees earning more than ₹50,000 false -> Employees earning ₹50,000 or less ✔ Automatically groups into two categories ✔ Ideal for binary conditions (true/false) 📊 Output Structure true -> List of high-salary employees false -> List of other employees - Use partitioningBy when your condition results in only two groups. - If you need multiple groups (like department-wise), go for groupingBy. 💻 I’ve added my Java solution in the comments below. Please let me know if there are any other approaches I could try. #Java #JavaStreams #CodingInterview #BackendDevelopment #SpringBoot #Developers