Forem: Capwell Murimi

🚚 One-Time MySQL to PostgreSQL Migration with pgloader + Docker (Windows-Friendly)

Capwell Murimi — Thu, 24 Apr 2025 17:22:05 +0000

Hey folks 👋 I’m Capwell, and I recently had to migrate a MySQL database to PostgreSQL. It wasn’t a continuous sync — just a one-time migration — so I needed a quick, clean way to do it.

When you’re on Windows,You don’t want to install a bunch of tools, and just need something that works without drama, it can feel like a puzzle.

That’s what led me to pgloader + Docker — the perfect combo for a painless one-time migration. No native installs, no environment weirdness. Just results.

Here’s how I made it work

Installing Docker on Windows
If you’re using Windows (like I was), the easiest way to get started is by installing Docker Desktop. Here’s a quick walkthrough:

Download Docker Desktop
👉 Docker

Run the Installer
Follow the setup wizard. You’ll need WSL enabled (Windows Subsystem for Linux), which Docker will guide you through if it’s not already installed.

Launch Docker
Once installed, launch Docker Desktop. You should see the Docker whale icon in your system tray.

Why pgloader?
pgloader is an open-source tool that:

✅ Migrates schema and data
✅ Handles type conversions
✅ Works with MySQL, SQLite, MS SQL
✅ Supports load scripts for reusable, declarative migrations
✅ Can be run with Docker — no need to install anything

Step 1: Create a pgloader Load Script
In the folder where you want to run the migration, create a file called mysql_to_pg.load with the following content:

LOAD DATABASE
     FROM mysql://root:yourpass@host.docker.internal/source_db
     INTO postgresql://postgres:pgpass@host.docker.internal/target_db

WITH include drop, 
create tables, 
create indexes, 
reset sequences,
data only

SET work_mem to '16MB',
    maintenance_work_mem to '512 MB';

ALTER SCHEMA 'source_db' RENAME TO 'public';

🔁 Replace:

yourpass → your MySQL root password

pgpass → your PostgreSQL password

source_db / target_db → your actual DB names

Step 2: Run pgloader with Docker
Make sure Docker is installed and both MySQL/PostgreSQL are up and running.

On Windows (PowerShell)
powershell

docker run --rm -v "folder where the file is":/mnt dimitri/pgloader pgloader /mnt/mysql_to_pg.load

🛠 Common Pitfalls
✅ Make sure MySQL and Postgres are running

✅ Ensure firewall/ports aren’t blocking connections

✅ For Dockerized MySQL/Postgres, use a shared network or proper host IPs

💬 Final Thoughts
This approach:

✔️ Works on Windows (which I used)
✔️ Doesn’t require any installs (thanks to Docker)
✔️ Makes migrations repeatable with load scripts

For a one-time migration, it's hard to beat.

Got stuck?
Drop a comment below or ping me on Twitter

Navigating React's Seas of Data: The Enchantment of useContext - Part One

Capwell Murimi — Thu, 01 Feb 2024 16:57:19 +0000

In the vast ocean of React development, finding efficient ways to share and manage data across components is akin to discovering hidden treasures. In this captivating series, we set sail on a voyage through the waters of React Hooks, with Part One dedicated to unraveling the enchanting powers of useContext. Brace yourselves as we embark on a journey that promises to transform the way you handle state and context in your React applications.

The Prelude to Context Magic:
Before we dive into the wonders of useContext, let's set the stage with a glimpse into the challenges of sharing state between distant React components. In this chapter, we explore the complexities of prop drilling and discover why useContext emerges as the beacon of light in our quest for clean and maintainable code.

Unveiling the Oracle - Creating React Context:
The power of useContext lies in its connection to the mystical realms of React Context. Learn how to create a Context and establish a magical bond that transcends component hierarchies. As we unlock the secrets of this React Oracle, you'll witness the emergence of a shared space where data flows effortlessly, fostering a new era of component communication.

The Dance of Providers and Consumers:
In this chapter, we delve into the delicate dance between Providers and Consumers. Providers act as guardians of the sacred data, while Consumers, armed with useContext, tap into the wellspring of information. Witness the elegant choreography that unfolds as we orchestrate this dance, creating a harmonious symphony of components that seamlessly share their tales.

Practical Sorcery - Real-world Applications of useContext:
No journey is complete without practical applications. In this chapter, we apply the wisdom gained from the previous chapters to real-world scenarios. Discover how useContext can simplify the implementation of themes, authentication, and other shared states, transforming your codebase into a realm of clarity and elegance.

As we wrap up Part One of our exploration, it feels like we're standing at the edge of this incredible sea called useContext in the React world. But hold on, the story has only just begun. The little marks we've made on the shore are like a teaser to the grand adventure that lies ahead.

In the vast landscape of React, useContext has become our trusty guide, steering us through unknown territories where code becomes more efficient and expressive. Can you feel the excitement? Our sails are fluttering, and we're getting ready for the next part of this journey.

The tales of useContext are not fading away anytime soon. In the next chapter, we're going to unfold the mysteries in Chapter One, going deeper into the secrets that React Hooks have in store for those who dare to take on this thrilling ride. The story unfolds, and the magic of useContext is still calling out to those brave souls ready to dive deeper into the wonders of React.

So, dear adventurer, tighten your grip on your compass because the journey is far from over. The odyssey continues, and as we sail forward, new surprises and insights are just waiting to be discovered on the horizon. Get ready for the next wave of revelations!

Unleashing the Power of useEffect

Capwell Murimi — Sat, 05 Aug 2023 16:39:56 +0000

Have you ever wanted to make your web page or app more interactive and fun? In the world of web development, we have a powerful tool called the useEffect hook that allows us to do just that. In this article, we'll explore how the useEffect hook works and how it can bring your web projects to life.

Imagine you have a toy robot that can do different things. Sometimes, you want the robot to do something special when a certain condition is met. That's where the useEffect hook comes in.
The useEffect hook is like a special command you give to the robot. You tell the robot, "Hey, whenever this condition is true, do this special action." The condition could be something like a button being clicked or a number changing.
For example, let's say you have a button on a webpage. When you click the button, you want the robot to make a sound. You can use the useEffect hook to tell the robot, "Hey, whenever the button is clicked, make a sound."
The useEffect hook works like this: you give it two things. First, you give it the special action you want the robot to do. In our case, it's making a sound. Second, you give it the condition that triggers the action. In our case, it's the button being clicked.
The robot listens for the condition to happen. When it does, it performs the special action. In our example, when you click the button, the robot makes a sound.
The useEffect hook is really helpful because it allows you to control when the robot should do something special. You can tell it to do the action only once, or every time the condition happens.
It's important to remember that the robot can also clean up after itself. For example, if the robot creates some mess while making the sound, it can clean it up when it's done. This is called the clean-up function, and it's like the robot taking care of its mess.
So, the useEffect hook is like giving instructions to a robot. You tell it what to do and when to do it. It's a way to make your web page or app more interactive and fun!

Sorting Simplified: The Quirky World of Selection Sort

Capwell Murimi — Thu, 01 Jun 2023 13:45:30 +0000

Sorting can be a perplexing ordeal, like trying to find matching socks in a laundry basket. Fear not! We’re here to unravel the secrets of the selection sort algorithm, a peculiar creature that loves finding the most minor elements and putting them in their rightful places. Get ready to embark on a comical journey through the whimsical world of selection sort!

Once upon a time, in the kingdom of Arraysville, there lived an algorithm called selection sort. This quirky algorithm had a unique way of sorting arrays by repeatedly seeking out the tiniest elements and swapping them with the lucky residents of the sorted kingdom. Let’s delve into the peculiar steps of this delightful dance!

Step-by-Step Adventure:

Our adventure begins with a disorderly array. It’s like a group of mischievous cats, each vying for attention.
The sorted kingdom starts at the beginning of the array, sipping tea and waiting for the festivities to commence.
With a swish of its magical wand, selection sort starts iterating through the array, examining each cat — I mean, element — one by one.
In each encounter, selection sort identifies a potential candidate for the coveted “tiniest element” title. It has an eye for spotting those fluffy little integers!
Like a game show host, selection sort challenges the remaining elements, asking, “Are you smaller than our esteemed candidate? Show me what you’ve got!”
Whenever a smaller element is found, selection sort joyfully adjusts its candidate, eager to crown the new winner. Talk about a competitive spirit!
After thoroughly inspecting the contestants, selection sort confidently swaps the newly crowned tiniest element with the resident at the front of the sorted kingdom. It’s like sending a champion to reign in the right place!
With every successful swap, the sorted kingdom expands, and the boundary moves forward, leaving behind a trail of harmonious integers.
Selection sort waves its wand again, ready for the next round of the “find the tiniest” game. It repeats steps 3 to 8 until the entire array is sorted, leaving no feline — I mean, element — behind.

Now, let’s address the elephant in the room — time complexity. Brace yourself! Selection sort has a bit of a dramatic side. It performs a linear search in each iteration, like a lost traveler searching for the perfect souvenir. As a result, the time required to sort grows exponentially with the array’s size, just like a magician pulling rabbits out of a hat. It’s a bit slow for large arrays, but perfect for a leisurely stroll with smaller datasets.🕰️🐇

Selection sort might not be the fastest horse in the race, but it has its moments of glory. It shines when the array is partially sorted or when you’re feeling nostalgic for the good ol’ days of sorting. It’s like the reliable grandparent who tells stories of simpler times. However, for larger arrays, consider enlisting the help of more efficient algorithms like merge sort or quicksort, the speedsters of the sorting world.🏎️💨

In the wacky realm of sorting algorithms, selection sort stands as an endearing character, tirelessly searching for the tiniest elements and placing them in their rightful positions. Although its time complexity might raise a few eyebrows, it’s a lovable choice for smaller arrays and a delightful introduction to the enchanting world of sorting. So, grab your popcorn and witness the whimsical dance of selection sort — the sorting algorithm that proves even the quirkiest creatures can bring order to chaos!✨🎩🎶

Remember, sorting algorithms are like a circus of techniques, each with its own charm and peculiarities. Exploring the colorful world of sorting is not only educational but also an opportunity to embrace the humor and imagination that algorithms can inspire. Happy sorting! 🎪🤹

How to Validate Credit Card Numbers Using the Luhn Algorithm in C

Capwell Murimi — Tue, 16 May 2023 20:42:34 +0000

Credit card validation is an important part of e-commerce and online transactions. In order to prevent fraud and ensure that transactions are secure, it's essential to verify that the credit card number entered by the user is valid. In this article, we'll explore how to validate credit card numbers using the Luhn algorithm in C.

What is the Luhn Algorithm?

The Luhn algorithm, also known as the "modulus 10" algorithm, is a simple checksum formula used to validate a variety of identification numbers, including credit card numbers. The algorithm works by summing up the digits of the number, starting from the rightmost digit and moving left. If the sum is divisible by 10, then the number is considered valid.

How does it work ?

Multiply every other digit by 2, starting with the number’s second-to-last digit, and then add those products’ digits together.
Add the sum to the sum of the digits that weren’t multiplied by 2.
If the total’s last digit is 0 (or, put more formally, if the total modulo 10 is congruent to 0), the number is valid!

An example;

For the sake of discussion, let’s first underline every other digit, starting with the number’s second-to-last digit:

4003600000000014

Okay, let’s multiply each of the underlined digits by 2:

1•2 + 0•2 + 0•2 + 0•2 + 0•2 + 6•2 + 0•2 + 4•2

That gives us:

2 + 0 + 0 + 0 + 0 + 12 + 0 + 8

Now let’s add those products’ digits (i.e., not the products themselves) together:

2 + 0 + 0 + 0 + 0 + 1 + 2 + 0 + 8 = 13

Now let’s add that sum (13) to the sum of the digits that weren’t multiplied by 2 (starting from the end):

13 + 4 + 0 + 0 + 0 + 0 + 0 + 3 + 0 = 20

Yup, the last digit in that sum (20) is a 0, so David’s card is legit!

So, validating credit card numbers isn’t hard, but it does get a bit tedious by hand. Let’s write a program.

The Code
Let's take a look at the code for validating credit card numbers using the Luhn algorithm in C:

pseudocode:

1. Prompt the user to enter a credit card number
2. Read the credit card number from the user
3. Check if the credit card number is valid (greater than 0)
4. If the credit card number is not valid, go back to step 1
5. Extract the first few digits of the credit card number to determine the type of card
6. Initialize a variable to store the sum of the digits
7. While the credit card number is greater than 0:
   a. Get the last digit of the credit card number using the modulus operator
   b. Remove the last digit from the credit card number using integer division
   c. Increment a counter to keep track of the number of digits
   d. If the current digit is even (based on the counter):
      i. Double the digit
      ii. If the result is greater than 9, subtract 9 from it
   e. Add the current digit (or the doubled digit) to the sum
8. Check if the sum is divisible by 10
9. If the sum is divisible by 10:
   a. Check the first few digits of the credit card number to determine the type of card
   b. Print the name of the card (AMEX, MASTERCARD, VISA) or "INVALID"
10. If the sum is not divisible by 10, print "INVALID"
11. Terminate the program

The actual code:

The code starts by asking the user to enter a credit card number. It then uses a do-while loop to ensure that the user enters a positive number.
Next, the code extracts the first few digits of the credit card number to determine the type of card. For example, American Express cards typically start with the digits 34 or 37, so the code divides the credit card number by 10^13 and stores the result in the amex variable. Similarly, Mastercard cards typically start with the digits 51, 52, 53, 54, or 55, so the code divides the credit card number by 10^14 and stores the result in the master variable. Visa cards can start with the digit 4, so the code divides the credit card number by 10^12 and 10^15 and stores the results in the visa array.
The code then applies the Luhn algorithm to the credit card number to calculate a checksum. The algorithm works by iterating over the digits of the number, starting from the rightmost digit and moving left. If the current digit is even, the code doubles it and subtracts 9 if the result is greater than 9. The code then adds the current digit (or the doubled digit) to a running sum.
Finally, the code checks if the checksum is valid by checking if the sum is divisible by 10. If the checksum is valid, the code checks the first few digits of the credit card number to determine the type of card. If the card is a valid American Express, Mastercard, or Visa card, the code prints the name of the card. Otherwise, the code prints "INVALID".

Conclusion:
In this article, we've explored how to validate credit card numbers using the Luhn algorithm in C. We've seen how the algorithm works, and how to implement it in code using loops, conditionals, and arrays. We've also discussed how to extract the first few digits of a credit card number to determine the type of card. By following these steps, you can ensure that your e-commerce and online transactions are secure and free from fraud.