Estimating the development timeline for an API when SQL queries are ready

Estimating the development timeline for an API when SQL queries are ready involves evaluating several factors. Here's a step-by-step approach:

1. Define API Scope

• Number of Endpoints: Count how many API endpoints need to be created.
• Complexity per Endpoint: Consider if endpoints are simple (e.g., a single query) or complex (e.g., require multiple queries or custom logic).
• Authentication and Authorization: Determine if additional work is needed for securing the API.

2. Assess Development Components

• Data Layer: Since SQL queries are ready, consider if additional transformations or validations are needed before returning data.
• Business Logic: Identify if any specific computations or logic need to be applied to the data retrieved by SQL.
• API Design:
  • Standardize response formats (e.g., JSON, XML).
  • Error handling and status codes.
• Documentation: Include time for creating API documentation (e.g., Swagger, Postman).

3. Select Tools and Frameworks

• Framework Choice: The time required may vary depending on the API framework or language (e.g., Flask, Django, Express.js).
• Existing Boilerplate: If you have a starter template or boilerplate, it can save significant time.

4. Allocate Time per Endpoint

• Simple endpoints: 1–2 hours (direct query mapping).
• Medium complexity: 3–5 hours (data transformation or minor business logic).
• High complexity: 6+ hours (multiple queries, external integrations).

5. Include Testing

• Unit testing for individual functions.
• Integration testing for endpoints.
• Load testing if performance is critical.

6. Deployment and Setup

• Include time for setting up the server, deploying the API, and configuring CI/CD pipelines.

7. Buffer for Debugging

• Add a buffer of 10–20% for unforeseen issues, such as debugging or performance optimizations.

Example Timeline

Task	Time Estimate
API design (initial)	4–8 hours
Simple endpoints	1–2 hours/endpoint
Medium complexity endpoints	3–5 hours/endpoint
High complexity endpoints	6–10 hours/endpoint
Authentication setup	6–10 hours
Testing	10–15% of development time
Deployment and setup	4–8 hours

Tips for Accuracy

• Break down tasks as granularly as possible.
• Review estimates with the team (if applicable).
• Use past project timelines as references.

Allowed memory size of 134217728 bytes exhausted (tried to allocate 20971520 bytes) while accessing a page of the site

 Fatal Error: Allowed Memory Size of 134217728 Bytes Exhausted error in my web application, while accessing a page. To solve this issue, we have to do a configuration change in php.ini of our web server.

Follow these steps to update memory limit to resolve this error from the Mac/Ununtu terminal:

1. Determine PHP version from terminal

RUN: php -v

2. Navigate to php.ini file

REFERENCE: nano /etc/php/{PHP_VERSION}/php.ini

RUN: nano /etc/php/8.3/php.ini

3. Use up and down arrows to locate memory storage and update storage allocation (this was surprisingly far down) memory_limit = 128M

Update to 256M

4. Save and exit php.ini

Ctrl + O to save changes in nano

Enter to save to file

Ctrl + X to exit

This resolved this error for me! Hope this helps

How to get the auto incremented id after adding the data in mysql

 In one of the project we were working on, we had a situation, where we need to add a record to the table of the database. The added record id is auto incremented in database. This id needs to added to another table with some more data. Now the issue here is how to get the auto increamented value of the previous table. 

In PHP, you can retrieve the auto-incremented ID generated by a INSERT operation in a MySQL database using the mysqli_insert_id() function. Here's how you can do it:

Example Code

<?php
// Database connection
$servername = "localhost";
$username = "root";
$password = "";
$database = "your_database";

$conn = new mysqli($servername, $username, $password, $database);

// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

// Insert query
$sql = "INSERT INTO your_table (column1, column2) VALUES ('value1', 'value2')";
if ($conn->query($sql) === TRUE) {
    // Get the last inserted ID
    $last_id = $conn->insert_id;
    echo "New record created successfully. Last inserted ID is: " . $last_id;
} else {
    echo "Error: " . $sql . "<br>" . $conn->error;
}

// Close connection
$conn->close();
?>

Explanation

1. Database Connection: Establishes a connection to the MySQL database using mysqli.
2. Insert Query: Executes an INSERT statement.
3. Retrieve Last ID:
   • $conn->insert_id retrieves the auto-incremented ID of the last inserted record.
4. Error Handling: Checks if the query was successful before attempting to retrieve the ID.
5. Close Connection: Always close the database connection after performing operations.

Notes

• Make sure the column is defined as AUTO_INCREMENT in the table schema.
• If you're using a database abstraction library like PDO, you can use PDO::lastInsertId() instead.
• Ensure proper escaping or use prepared statements to prevent SQL injection. For example:

$stmt = $conn->prepare("INSERT INTO your_table (column1, column2) VALUES (?, ?)");
$stmt->bind_param("ss", $value1, $value2);
$stmt->execute();
$last_id = $stmt->insert_id;
$stmt->close();

This approach is more secure and should be preferred for user input.

In Laravel, retrieving the auto-incremented ID after inserting a record is straightforward, especially if you are using Eloquent or the query builder.
Using Eloquent
If you are using Eloquent, the save method or the create method automatically returns the auto-incremented ID of the record.

// Example 1: Using save()
$model = new YourModel();
$model->column1 = 'value1';
$model->column2 = 'value2';
$model->save();
$lastInsertedId = $model->id; // Retrieves the auto-incremented ID
// Example 2: Using create()
$model = YourModel::create([
'column1' => 'value1',
'column2' => 'value2',
]);
$lastInsertedId = $model->id; // Retrieves the auto-incremented ID

Using Query Builder

If you are using Laravel's query builder, you can use the insertGetId method, which inserts a record and directly returns the auto-incremented ID.

$lastInsertedId = DB::table('your_table')->insertGetId([
'column1' => 'value1',
'column2' => 'value2',
]);
echo "The last inserted ID is: " . $lastInsertedId;

Explanation
Eloquent Approach:

• $model->save(): Saves the record to the database and updates the $model->id property with the auto-incremented ID.

• YourModel::create(): Inserts the record and returns the model instance with the id property set.

• Ensure that the $fillable property in your model is defined for mass assignment in create().

Query Builder Approach:

• insertGetId: Inserts the record and directly returns the ID of the inserted record.

Notes

• Eloquent automatically manages timestamps (created_at, updated_at) if the table has them, so you don't need to handle them manually.

• If using create(), make sure the YourModel class has the $fillable or $guarded property defined:

• For additional security, always validate and sanitize input data before inserting it into the database. Use Laravel's validation mechanisms.

protected $fillable = ['column1', 'column2'];

How to check and change innodb buffer pool size in mysql database

 The InnoDB buffer pool size in MySQL determines how much memory is allocated to store frequently accessed data and indexes. To check and change it, follow these steps:

1. Check Current InnoDB Buffer Pool Size

    Log in to MySQL

        mysql -u root -p

   Run the Following Query

        SHOW VARIABLES LIKE 'innodb_buffer_pool_size';

This will display the current size in bytes.

---

2. Change InnoDB Buffer Pool Size

    a. Edit the MySQL Configuration File

The InnoDB buffer pool size is set in the MySQL configuration file (my.cnf or my.ini).

1. Open the configuration file in a text editor (e.g., nano on Ubuntu):

   sudo nano /etc/mysql/my.cnf

2. Locate the [mysqld] section and add or update the following line:

   innodb_buffer_pool_size = 1G

   Replace 1G with the desired size (e.g., 512M, 2G, etc.).

   • Best Practice: Set the buffer pool size to around 70-80% of your server's total RAM if MySQL is the primary application on the server.

    b. Save and Exit

    Save the changes and exit the text editor.

    c. Restart MySQL Service

        Restart MySQL to apply the changes:

        sudo systemctl restart mysql

---

3. Verify the Change

Log in to MySQL again and run the query to confirm the new buffer pool size:

        SHOW VARIABLES LIKE 'innodb_buffer_pool_size';

---

Additional Notes

• For servers with large memory, consider splitting the buffer pool into multiple instances:

  innodb_buffer_pool_instances = 4

  This setting improves performance for systems with a high buffer pool size.

• If MySQL fails to restart, check the error log for details:

  sudo tail -n 50 /var/log/mysql/error.log

Setting of Auto backup of Mysql database in a laravel project

 When we work on any database project, it's always good to set up autoback of the database on daily basis. We can set up a cron job for backing up a MySQL database in a Laravel project, follow these steps:

1. Create a Laravel Artisan Command

1. Run the following command to create a custom Artisan command:

   php artisan make:command BackupDatabase

2. Open the generated file in app/Console/Commands/BackupDatabase.php and update its content:

   <?php
   
   namespace App\Console\Commands;
   
   use Illuminate\Console\Command;
   use Illuminate\Support\Facades\Storage;
   
   class BackupDatabase extends Command
   {
       /**
        * The name and signature of the console command.
        *
        * @var string
        */
       protected $signature = 'backup:database';
   
       /**
        * The console command description.
        *
        * @var string
        */
       protected $description = 'Backup the MySQL database';
   
       /**
        * Execute the console command.
        */
       public function handle()
       {
           $dbName = env('DB_DATABASE');
           $dbUser = env('DB_USERNAME');
           $dbPassword = env('DB_PASSWORD');
           $dbHost = env('DB_HOST', '127.0.0.1');
   
           $backupPath = storage_path('app/backups/' . date('Y-m-d_H-i-s') . '_backup.sql');
   
           // Ensure the backup directory exists
           Storage::makeDirectory('backups');
   
           $command = sprintf(
               'mysqldump -u%s -p%s -h%s %s > %s',
               escapeshellarg($dbUser),
               escapeshellarg($dbPassword),
               escapeshellarg($dbHost),
               escapeshellarg($dbName),
               escapeshellarg($backupPath)
           );
   
           $result = null;
           $output = null;
   
           exec($command, $output, $result);
   
           if ($result === 0) {
               $this->info('Database backup created successfully: ' . $backupPath);
           } else {
               $this->error('Failed to create database backup.');
           }
       }
   }
   

---

2. Schedule the Command in Laravel

1. Open the app/Console/Kernel.php file.

2. Register the new command in the schedule method:

   protected function schedule(Schedule $schedule)
   {
       $schedule->command('backup:database')->dailyAt('02:00');
   }
   

   This schedules the backup to run daily at 2:00 AM. Adjust the time as needed.

---

3. Set Up the Cron Job

1. Open the cron jobs configuration file:

   crontab -e

2. Add the following line to execute Laravel's scheduler every minute:

   * * * * * php /path-to-your-laravel-project/artisan schedule:run >> /dev/null 2>&1

   Replace /path-to-your-laravel-project with the actual path to your Laravel application.

---

4. Verify Backup Files

1. The backups will be stored in the storage/app/backups directory.
2. Ensure the directory is writable by the web server and the Laravel application.

---

5. Additional Suggestions

• Compression: Modify the command to compress the backup:

  $command = sprintf(
      'mysqldump -u%s -p%s -h%s %s | gzip > %s.gz',
      escapeshellarg($dbUser),
      escapeshellarg($dbPassword),
      escapeshellarg($dbHost),
      escapeshellarg($dbName),
      escapeshellarg($backupPath)
  );
  

• Cloud Storage: Use Laravel's filesystem to store the backups on S3, Google Cloud Storage, etc.