DEV Community: Lucas Kuhn

Polymorphic vs Shared Table: Is speed a valid concern?

Lucas Kuhn — Sat, 29 Jun 2024 14:39:35 +0000

What do you do when you find a model that can belong to multiple models?

In my case, I'm building the inventory tracking functionality for an MRP. An Inventory Item can be either related to a Product, or a Material - in summary, I need to find a way to relate the two tables on the left, to the table on the right:

What usually comes to mind is using a polymorphic relationship. Let's call this poly_inventory_item:

This way, the item_id field is a foreign key and the item_type will let us know if it is a material or a product. This has some strong points:

Clean solution with only two fields
Flexibility to add more relations in the future

However, since there are only two options (either a material or a product), a table with two foreign keys is also a viable option. Let's call this shared_inventory_item:

This case is a bit unusual since it has nullable foreign keys, but it comes with some advantages:

Clearer relations, as you can see the foreign keys directly
Faster speeds, due to the indexes on the foreign keys

This second assumption, is what made me question my decision. How much faster can it be?

Testing the speed of both relations

I'm using Rails and SQLite for this test, and tested the speed in some common operations: creating records, getting the item, and querying the table.

Database setup

Standard indexes expected for the shared table and the polymorphic table:

# db/schema.rb
create_table "poly_inventory_items", force: :cascade do |t|
  t.string "item_type", null: false
  t.integer "item_id", null: false
  t.index ["item_type", "item_id"], name: "index_poly_inventory_items_on_item"
end
create_table "shared_inventory_items", force: :cascade do |t|
  t.integer "product_id"
  t.integer "material_id"
  t.index ["material_id"], name: "index_shared_inventory_items_on_material_id"
  t.index ["product_id"], name: "index_shared_inventory_items_on_product_id"
end
add_foreign_key "shared_inventory_items", "materials"
add_foreign_key "shared_inventory_items", "products"

Models setup

Very simple definition and validations for the polymorphic table:

class PolyInventoryItem < ApplicationRecord
  belongs_to :item, polymorphic: true
  validates :item_type, inclusion: {in: %w[Product Material]}
end

The shared table is a bit more complex, as it needs to validate the presence of one of the foreign keys, and the absence of the other:

class SharedInventoryItem < ApplicationRecord
  belongs_to :product, optional: true
  belongs_to :material, optional: true

  validates :product_id, presence: true, unless: :material_id?
  validates :material_id, presence: true, unless: :product_id?

  validates :product_id, absence: true, if: :material_id?
  validates :material_id, absence: true, if: :product_id?
end

On the other side, the Material and Product can be very straightforward:

class Material < ApplicationRecord
  has_one :shared_inventory_item
  has_one :poly_inventory_item, as: :item
end

class Product < ApplicationRecord
  has_one :shared_inventory_item
  has_one :poly_inventory_item, as: :item
end

Benchmarking

Since indexes matter more on a large database, I did all tests in a situation with only a thousand records, and again with 100K records. The tests were done using the benchmark-ips gem.
I tested the most important operations for my use case: creating records, reading from the association, and querying the table.

# --- Creating records
Benchmark.ips do |x|
  x.report("PolyInventoryItem") do
    material = Material.create!(name: "Material")
    product = Product.create!(name: "Product", sku: "SKU")
    material.create_poly_inventory_item!
    product.create_poly_inventory_item!
  end
  x.report("SharedInventoryItem") do
    material = Material.create!(name: "Material")
    product = Product.create!(name: "Product", sku: "SKU")
    material.create_shared_inventory_item!
    product.create_shared_inventory_item!
  end
  x.compare!
end
# --- Reading from association
Benchmark.ips do |x|
  x.report("PolyInventoryItem") do
    Product.first.poly_inventory_item
    Material.first.poly_inventory_item
  end
  x.report("SharedInventoryItem") do
    Product.first.shared_inventory_item
    Material.first.shared_inventory_item
  end

  x.compare!
end
# --- Querying
product = Product.first
material = Material.first
Benchmark.ips do |x|
  x.report("PolyInventoryItem") do
    PolyInventoryItem.find_by(item: product)
    PolyInventoryItem.find_by(item: material)
  end
  x.report("SharedInventoryItem") do
    SharedInventoryItem.find_by(product: product)
    SharedInventoryItem.find_by(material: material)
  end

  x.compare!
end

Results

Creating records

 --- 1K records
 SharedInventoryItem:    409.4 i/s
 PolyInventoryItem:      394.5 i/s - same-ish: difference falls within error
 --- 100K records
 SharedInventoryItem:    378.4 i/s
 PolyInventoryItem:      377.4 i/s - same-ish: difference falls within error

Reading from association

 --- 1K records
  SharedInventoryItem:     1982.0 i/s
    PolyInventoryItem:     1863.5 i/s - 1.06x  slower
 --- 100K records
  SharedInventoryItem:     1915.8 i/s
    PolyInventoryItem:     1761.8 i/s - 1.09x  slower

Querying

 --- 1K records
  SharedInventoryItem:     7471.5 i/s
    PolyInventoryItem:     4476.7 i/s - 1.67x  slower
 --- 100K records
  SharedInventoryItem:     6686.9 i/s
    PolyInventoryItem:     3862.5 i/s - 1.73x  slower

The query with find_by is the one that makes most use of the indexes, and it is the one that has the most significant difference. However, this would only by useful if you are querying the table instead of the association.

Conclusion

I was surprised to see that the speed difference was not as significant as I thought. For the most part, the polymorphic relation is as fast as the shared table, it is also cleaner and easier to maintain. It all comes down to the trade-offs you are willing to make.

I will stick with the polymorphic relation. Hope this helps you make a decision in the future! 🙌

A simple guide to Action Cable

Lucas Kuhn — Thu, 06 May 2021 02:00:19 +0000

Action cable is the Rails way of implementing WebSockets - with some Rails magic.

Repository for this app here

Why use it

Usually your client connects with your server by making requests:

With ActionCable, you create an open connection between your client and your server, allowing a communication flow:

Example:

You have a simple blog - posts and comments - and multiple users reading that post. If one user adds a comment, the others will never know:

But with the open connection from ActionCable, they will get instant updates for that post 🔥

How to do it

First of all, generate a channel for your Posts. This class will be able to broadcast updates to all clients listening:



rails generate channel posts

Which will create some files for you:



      create    test/channels/posts_channel_test.rb
      create  app/channels/posts_channel.rb
   identical  app/javascript/channels/index.js
   identical  app/javascript/channels/consumer.js
      create  app/javascript/channels/posts_channel.js

Sending messages

We will work with our newly generated posts_channel.rb

We want to specify from which channel to stream, so we can pass an id params and ask rails to make a stream for that post:



class PostsChannel < ApplicationCable::Channel
  def subscribed
    post = Post.find(params[:id])
    stream_for post
  end
end

And now, from anywhere in our app, we can call PostsChannel and ask it to broadcast something to anyone listening to that post:



PostsChannel.broadcast_to(@post, “hello world”)

We will add this to our create action, to broadcast the comment to the post channel every time a comment is created:



# app/controllers/comments_controller.rb

def create
  @comment = @post.comments.new(comment_params)
    if @comment.save
      PostsChannel.broadcast_to(@post, @comment.body)
      redirect_to @post, notice: "Comment was successfully created."
    else
      render :new
    end
end

And that does nothing so far since no one is listening to this broadcast. Moving forward!

Receiving messages

Opinionated setup:

I do not like to create a separate file for every consumer, I prefer to do the connection in script tags in the view. It feels more like a separate front end, where only the view that needs a connection creates one.
To do so, add this snippet in app/javascript/channels/index.js:



// Expose action cable
import * as ActionCable from '@rails/actioncable'
window.App || (window.App = {});
window.App.cable = ActionCable.createConsumer();

Note: Exposing the cable was the default according to official docs until Rails 6, where Webpacker was introduced

The rails generator we used before created a file in app/javascript/channels/posts_channel.js
Here’s why we won’t use it:

It is always required, so whatever we put in it will run on every page of our app
We don’t want everyone opening a connection to get updates, just the people on our post show page

So you can go ahead and delete the created posts_channel.js 🗑

And add a code to listen to our broadcast on the post show page:



<!-- app/views/posts/show.html.erb -->

<script>
  App.cable.subscriptions.create({ channel: "PostsChannel", id: "<%= @post.id %>" }, {
    connected() {
      console.log("Connected to the channel:", this);
    },
    disconnected() {
      console.log("Disconnected");
    },
    received(data) {
      console.log("Received some data:", data);
    }
  });
</script>

And now, upon opening our blog post page, we can see the connected message on our terminal, and some Rails magic that enabled this connection:

The posts:Z2lkOi8vYWN0aW9uY2FibGUtYXBwL1Bvc3QvMg is the name of the channel created by rails when we told it to stream_for post in our posts_channel file.

And you’re done! 🎉
~Almost~

While the above script received data, it doesn’t show it on the page. We can update it to add the comment to our list upon receiving them:



App.cable.subscriptions.create({ channel: "PostsChannel", id: "<%= @post.id %>" }, {
  received(comment) {
    el = document.createElement('li');
    el.innerHTML = comment;
    document.querySelector('ul').appendChild(el)
  }
});

(All functions are optional, I removed the disconnected and connected ones)

And there you go, your app now talks to any browser listening to it via Action Cable:

Full code repo: GitHub: actioncable-app

References

Rails Guide:
https://guides.rubyonrails.org/action_cable_overview.html
Heroku Guide:
https://blog.heroku.com/real_time_rails_implementing_websockets_in_rails_5_with_action_cable
Cable.yml Config:
https://github.com/rails/rails/issues/28118
Cable for specific pages:
https://stackoverflow.com/questions/39597665/rails-actioncable-for-specific-pages
https://stackoverflow.com/questions/36438323/page-specific-actioncable
Good JS subscription examples:
https://stackoverflow.com/questions/39597665/rails-actioncable-for-specific-pages
https://samuelmullen.com/articles/introduction-to-actioncable-in-rails-5/
https://stackoverflow.com/questions/36266746/actioncable-not-receiving-data
Usage with ActiveJob
https://www.pluralsight.com/guides/creating-a-chat-using-rails-action-cable
Cable on ReactNative
https://stackoverflow.com/questions/43510021/action-cable-not-receiving-response-on-client
AnyCable
Action Cable vs AnyCable: fight! | Nebulab

Syncing files from AWS S3 to local storage on Rails

Lucas Kuhn — Mon, 15 Feb 2021 14:36:08 +0000

I usually use Amazon S3 for storing images with Active Storage. There are some issues when pulling my database to work with it on localhost:

I don't want to accidentally delete something on S3
I don't want my localhost without images 🥲

I added this rake task to download files from S3 and format them in a way that works with local storage:

# lib/tasks/s3_to_local.rake 
desc "Sync files from S3 bucket to local storage folder"

task :s3_to_local do

  s3_bucket = "YOUR_S3_BUCKET"
  access_key_id = Rails.application.credentials.dig(:aws, :access_key_id)
  secret_access_key = Rails.application.credentials.dig(:aws, :secret_access_key)

  storage_folder = Rails.root.join('storage')
  storage_folder.mkpath

  system("AWS_ACCESS_KEY_ID=#{access_key_id} AWS_SECRET_ACCESS_KEY=#{secret_access_key} aws s3 sync s3://#{s3_bucket} #{storage_folder}")

  # Ignores sub_folders already created and .keep files
  images = storage_folder.children.select { |file| file.file? && !file.empty? }

  # Formats the file path of each image so ActiveStorage understands them using :local storage
  images.each do |path_name|
    dir, basename = path_name.split
    file_name = basename.to_s
    sub_folders = dir.join(file_name[0..1], file_name[2..3])
    sub_folders.mkpath # Create the subfolder used by active_record
    path_name.rename(dir + sub_folders + basename) # Renames file to be moved into subfolder
  end

end

What makes this tricky is that S3 storage has everything in the root of the bucket, and when using local storage with ActiveStorage, everything should be under a subfolder.

Also, you need AWS CLI for this to work:

brew install awscli

Basically copy this task into lib/tasks/s3_to_local.rake, add your bucket name, your AWS credentials, run rake s3_to_local and you're good to go

Mac setup for a Developer in 2021

Lucas Kuhn — Wed, 25 Nov 2020 13:44:50 +0000

I updated my Mac to BigSur, and decided to factory reset everything. Here's a tutorial for setting things up from scratch 🚀

First things first

Start by installing HomeBrew, and a few essential apps. Feel free to skip any app you don't want

Install HomeBrew to manage your packages. It comes with cask, so installing apps is a breeze 😌

  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

Then use brew to install some recommended apps:

Iterm2 for a better terminal

brew install iterm2

Brave for a better browser

brew install brave-browser

Rectangle for window management ( I use the spectacle settings )

brew install rectangle

1Password for password management

brew install 1password

VSCode as an editor

brew install visual-studio-code

Atom as another editor

brew install atom

Kap for screen recording (I used it for creating the gif below)

brew install kap

Make your terminal pretty

This will be the final look:

Install Oh My Zsh

  sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Set a theme for Oh My Zsh ( I use theunraveler )

open ~/.zshrc
ZSH_THEME="theunraveler"

[Optional] Set a color theme for iTerm ( I love the one by Clovis, instruction below )

  Download the .itermcolors file from:   https://github.com/Clovis-team/clovis-open-code-extracts/tree/master/utils
  Preferences -> Profile -> Colors -> Import

Setup ZSH suggestions

brew install zsh-autosuggestions

Setup ZSH Syntax highlighting

brew install zsh-syntax-highlighting

Setup ZSH Completions

brew install zsh-completions

Improve iTerm2 window looks

Open iTerm2, and go to:
Settings -> Appearance -> Theme: Minimal

Change the font to Menlo (available by default)

Preferences -> Profile -> Text -> Font: Menlo

Or install a custom font. I like Hack Font from Nerd Fonts (The one I use in the gif)

brew tap homebrew/cask-fonts
brew install font-hack-nerd-font
brew untap homebrew/cask-fonts

Other worthy mention fonts:

- Fira Code 
- Source Code Pro
- Cascadia 
- Font Hack 
- Nerd Fonts

Remove the last login line on top of iterm:

cd ~ ; touch .hushlogin

[optional] I like traveling the terminal like I travel a code editor, with option + arrow to travel words etc. I created a gist on github with the extra keymappings

Sidenote for people on BigSur

MacOS for some reason forgets to ask for all permissions required by iTerm2, resulting in updates hanging when using home-brew. To fix that:

Open Security and Privacy -> Privacy Tab -> Full Disk Access -> Enable iTerm

Ruby Enviroment

Rbenv for managing ruby versions:

brew install rbenv ruby-build

Then install the latest stable ruby:

rbenv install -l

And enable rbenv on your shell:

rbenv init

Heroku CLI

brew tap heroku/brew && brew install heroku

VSCode Setup

After installing VSCode, let's go from the bloated default:

To a cleaner look:

Open your settings (cmd + ,) and add Fira Code as your code font, or other preferred font:

Then on settings, search for ligatures, click on edit settings.json, and change the ligatures line to:

"editor.fontLigatures": true

Open your extensions (cmd + shift + x or last button on the side bar) and install a better theme. I like Atom One Dark Theme. Also, install Prettier:

Then, go back to settings, and enable format on save. You can now focus on coding instead of formatting your code 🚀

-> Open settings
-> Check the box for Format on Save

Remove the clutter!

Remove thing you probably don't use, like the minimap, status bar on the bottom, and the activity bar with huge buttons on the left.

-> Open the VSCode commands ( cmd + shift + P )
-> Toggle Activity Bar Visibility 
-> Toggle Status Bar Visibility 
-> Toggle Minimap

Almost done! The last thing is adding some useful shortcuts. On every program I use, you can toggle tabs by calling cmd+1 for fist tab, cmd+2 for second, and so on. To do so in VSCode, open the shortcuts settings cmd+k cmd+s click on the top right to open keyboard shortcuts, and add these:

[
    // Open tabs with CMD    
    {
        "key": "cmd+1",
        "command": "workbench.action.openEditorAtIndex1"
    },
    {
        "key": "cmd+2",
        "command": "workbench.action.openEditorAtIndex2"
    },
    {
        "key": "cmd+3",
        "command": "workbench.action.openEditorAtIndex3"
    },
    {
        "key": "cmd+4",
        "command": "workbench.action.openEditorAtIndex4"
    },
    {
        "key": "cmd+5",
        "command": "workbench.action.openEditorAtIndex5"
    },
    {
        "key": "cmd+6",
        "command": "workbench.action.openEditorAtIndex6"
    },
    {
        "key": "cmd+7",
        "command": "workbench.action.openEditorAtIndex7"
    },
    {
        "key": "cmd+8",
        "command": "workbench.action.openEditorAtIndex8"
    },
    {
        "key": "cmd+9",
        "command": "workbench.action.openEditorAtIndex9"
    },

    // Toggle the leftmost bar with the huge icons
    {
        "key": "cmd+ctrl+b",
        "command": "workbench.action.toggleActivityBarVisibility"
    },
]

And you're done! Enjoy

Sources

General setup and terminal:

Ruby env:

Where to now?

Lucas Kuhn — Thu, 02 Jan 2020 18:01:04 +0000

Just read this lovely post:

https://dev.to/devteam/you-can-now-generate-self-hostable-static-blogs-right-from-your-dev-content-via-stackbit-7a5

And I wonder if I should start posting things here.

Also, is this still valid?

https://vocal.media/01/13-clean-and-simple-open-source-blogging-platforms-for-your-developer-blog