Question 1

What are SQL subqueries and nested queries? Provide examples and explain their use cases.

Accepted Answer

SQL subqueries and nested queries are powerful tools for performing complex queries. A subquery is a query within another SQL query, while a nested query refers to a query placed inside another query's `FROM` or `WHERE` clause.

### Example of a Subquery:
```sql
SELECT UserName FROM Users WHERE UserID IN (SELECT UserID FROM Orders WHERE OrderAmount > 100);
```
### Explanation:
- This query selects user names from the `Users` table where the `UserID` exists in the result set of the subquery, which retrieves `UserID`s from the `Orders` table with an `OrderAmount` greater than 100.

### Example of a Nested Query:
```sql
SELECT UserName, (SELECT COUNT(*) FROM Orders WHERE Orders.UserID = Users.UserID) AS OrderCount
FROM Users;
```
### Explanation:
- This nested query retrieves user names along with the count of their corresponding orders. The subquery counts the number of orders for each user based on their `UserID`.

### Use Cases:
- Subqueries are useful when you want to filter records based on the results of another query, such as finding users with orders above a certain amount.
- Nested Queries can be used when you need to calculate aggregates or perform calculations based on another query, like counting related records.

### Edge Cases:
- Be cautious with performance; subqueries can be less efficient than JOINs for large datasets. Also, ensure that the subquery returns a compatible data type with the outer query for correct execution.

Question 2

What are the key differences between REST and GraphQL API design? Provide a scenario where one might be preferred over the other.

Accepted Answer

REST and GraphQL are both approaches to API design but have significant differences:

1. Data Fetching: In REST, the client often makes multiple requests to different endpoints to gather related data. In GraphQL, clients can request all necessary data in a single query. 
   ```graphql
   query {
       user(id: 1) {
           name
           posts {
               title
               comments {
                   text
               }
           }
       }
   }
   ```

2. Versioning: REST APIs often require versioning (e.g., /v1/users) when changes occur. GraphQL APIs evolve without versioning, as clients specify their data needs.

3. Response Structure: REST responses can be verbose, with fixed data structures. GraphQL allows clients to specify the exact shape of the response.

Scenario: If you are building a mobile application that needs to display user profiles with varying levels of detail depending on user preferences, GraphQL would be a better choice due to its flexibility in fetching exactly what the client needs in a single request. In contrast, if you are developing a simpler application where each endpoint serves a specific resource (like an e-commerce API), REST could be more straightforward to implement.

Question 3

Can you explain SQL aggregate functions and how to use MAX, MIN, and AVG?

Accepted Answer

SQL aggregate functions perform calculations on multiple rows of a table and return a single value. The most common aggregate functions are MAX, MIN, and AVG.

- MAX() returns the highest value in a set.
- MIN() returns the lowest value in a set.
- AVG() calculates the average value of a numeric column.

Here’s an example SQL query that demonstrates the use of these functions:
```sql
SELECT MAX(salary) AS HighestSalary,
       MIN(salary) AS LowestSalary,
       AVG(salary) AS AverageSalary
FROM employees;
```
This query will return the highest, lowest, and average salary from the employees table.

Question 4

What is the difference between method overloading and method overriding in Object-Oriented Programming (OOP)?

Accepted Answer

In Object-Oriented Programming (OOP), method overloading and method overriding are two important concepts that enhance the functionality and flexibility of code.

- Method Overloading: This occurs when multiple methods in the same class have the same name but different parameters (type or number). It allows different implementations based on the method signature.

- Method Overriding: This occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. It allows a subclass to modify the behavior of a superclass method.

Here's an example in Python:
```python
class Calculator:
    def add(self, a: int, b: int) -> int:
        return a + b

def add(self, a: float, b: float) -> float:
        return a + b

class AdvancedCalculator(Calculator):
    def add(self, a: int, b: int) -> int:
        result = super().add(a, b)
        return result * 2  # Overriding the method

calc = AdvancedCalculator()
print(calc.add(2, 3))  # Calls overridden method
```

Question 5

Design a microservices architecture for an e-commerce application. What services would you create, and how would they communicate?

Accepted Answer

In designing a microservices architecture for an e-commerce application, we can break down the system into several key services:

1. User Service: Manages user profiles, authentication, and authorization.
2. Product Service: Handles product listings, details, and inventory management.
3. Cart Service: Manages user shopping carts and associated operations.
4. Order Service: Processes orders, payment, and order history.
5. Shipping Service: Manages shipping logistics and tracking.

### Communication:
- REST APIs: Most services can communicate using RESTful APIs. For example, the Cart Service can call the Product Service to retrieve product details.
- Message Broker: Use a message broker like RabbitMQ or Kafka for asynchronous communication, especially for events like 'Order Created' that might need to notify the Shipping Service.

### Example:
```plaintext
1. User initiates checkout in the Cart Service.
2. Cart Service calls Order Service to create an order.
3. Order Service publishes an event 'Order Created' to a message broker.
4. Shipping Service listens to this event and starts processing the shipment.
```
This allows for scalability and decoupled services, which can be deployed and maintained independently.

SarthiQ

Interview Preparation Guide

Groww
Questions & Answers

Document Details

Need Help?

Top Groww Interview Questions

Groww Interview Questions

A Software Engineer was asked

A Backend Developer was asked

Backend Developer

Software Engineer