temp_table 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 44da43c646cffbe6a251c79f16469da742f609adb204503bb8b0dc73605d6a9f
+  data.tar.gz: 39c4439c7934b9780522396cf5ad5763668fa0f4dcd5d23d4e93400edc3ad362
+SHA512:
+  metadata.gz: e8041d90092e7fd691affe89927f36bd8b194328a10d84455004d497c0ac20a5320ca38624bf83dcd5a92023107dcdb82cadc2feddea5d4285beaf1befb3ec30
+  data.tar.gz: 702c147394ba3572b8fc2eea6bf671825752a6f9fe3f3b459b36da6d925ba95b90c47a1e0dd17e56824a2733f7e819309bd906daf5d979f51ee51e07cd206475

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in temp_table.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -0,0 +1,19 @@
+PATH
+  remote: .
+  specs:
+    temp_table (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.3)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  rake (~> 13.0)
+  temp_table!
+
+BUNDLED WITH
+   2.3.7

data/README.md

@@ -0,0 +1,59 @@
+# TempTable
+
+You can create the temporary table using this gem so that you can make a temp table and store its data temproraly until the user's session is active.
+
+To create temporary table.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'temp_table'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install temp_table
+
+## Usage
+    # To create copy of existing table Example:
+    require "temp_table"
+    TempTable.copy("original_table_name", "temp_table_name")
+
+    # To create copy of existing table with extra columns Example:
+    TempTable.copy("original_table_name", "temp_table_name", [{ name: "temp_table_id", data_type: "integer" }])
+
+    # To insert row from original table to temp table Example:
+    TempTable.insert_row_from_original("original_table_name", original_table_id, "temp_table_name")
+
+    # To insert data to reference table Example:
+    TempTable.insert_row_from_reference("temp_reference_id", reference_id, data, "original_table_name", "temp_table_name")
+
+    # To create table Example:
+    columns = { id: "integer", name: "varchar", phone: "bigint", email: "string" }
+    TempTable.create("temp_table_name", columns)
+
+    # To fetch data from temporary table
+        # with condition
+        conditions = {
+            age: 25,
+            status: 'active'
+        }
+        TempTable.fetch("temp_table_name", conditions)
+        # without condition
+        TempTable.fetch("temp_table_name") # to fetch all data of the table
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shesh-08/temp_table.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/lib/temp_table/copy.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module TempTable
+  class Copy
+    attr_accessor :table_name, :original_table_name, :extra_columns
+
+    def initialize(original_table_name, table_name, extra_columns = nil)
+      super()
+      @table_name = table_name
+      @original_table_name = original_table_name
+      @extra_columns = extra_columns
+    end
+
+    def perform
+      ActiveRecord::Base.connection.execute <<-SQL.squish
+      CREATE TEMPORARY TABLE IF NOT EXISTS #{table_name} (
+        id SERIAL PRIMARY KEY,
+        original_id INTEGER
+      );
+      SQL
+      add_columns_from_original
+      add_extra_columns unless extra_columns.nil?
+      add_foreign_key
+    end
+
+    private
+
+    def add_columns_from_original
+      original_columns = ActiveRecord::Base.connection.columns(original_table_name).reject do |c|
+        c.name == "id"
+      end
+
+      return if original_columns.blank?
+
+      column_definitions = fetch_column_definitions(original_columns)
+
+      return if column_definitions.blank?
+
+      column_definitions_string = column_definitions.join(", ")
+
+      sql = <<-SQL.squish
+        ALTER TABLE #{table_name}
+        #{column_definitions_string};
+      SQL
+
+      Rails.logger.info("Executing SQL: #{sql}")
+
+      ActiveRecord::Base.connection.execute(sql)
+    rescue ActiveRecord::StatementInvalid => e
+      Rails.logger.info("SQL Error: #{e.message}")
+    end
+
+    def add_foreign_key
+      return unless temporary_table?(table_name)
+
+      if temporary_table?(original_table_name)
+        ActiveRecord::Base.connection.execute <<-SQL.squish
+          ALTER TABLE #{table_name}
+          ADD CONSTRAINT fk_original
+          FOREIGN KEY (original_id) REFERENCES #{original_table_name}(id);
+        SQL
+      else
+        Rails.logger.info("Cannot add foreign key: #{original_table_name} is not a temporary table.")
+      end
+    end
+
+    def temporary_table?(table_name)
+      ActiveRecord::Base.connection.tables.include?(table_name) &&
+        ActiveRecord::Base.connection.execute("SELECT pg_is_temp('#{table_name}')").first["pg_is_temp"]
+    end
+
+    def fetch_column_definitions(original_columns)
+      existing_columns = ActiveRecord::Base.connection.columns(table_name).map(&:name)
+
+      column_definitions_from_original = original_columns.reject do |column|
+        existing_columns.include?(column.name)
+      end
+      column_definitions_from_original.map do |column|
+        "ADD COLUMN #{column.name} #{column.sql_type}"
+      end
+    end
+
+    def add_extra_columns
+      existing_columns = ActiveRecord::Base.connection.columns(table_name).map(&:name)
+
+      column_definitions_from_original = extra_columns.reject do |column|
+        existing_columns.include?(column[:name])
+      end
+
+      return if column_definitions_from_original.blank?
+
+      column_definitions = extra_columns.map do |column|
+        "ADD COLUMN #{column[:name]} #{column[:data_type]}"
+      end
+
+      extra_difinitions_columns = column_definitions.join(", ")
+
+      ActiveRecord::Base.connection.execute <<-SQL.squish
+        ALTER TABLE #{table_name}
+        #{extra_difinitions_columns};
+      SQL
+    end
+  end
+end

data/lib/temp_table/create.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TempTable
+  class Create
+    attr_accessor :table_name, :columns
+
+    def initialize(table_name, columns)
+      super()
+      @table_name = table_name
+      @columns = columns
+    end
+
+    def perform
+      column_definitions = columns.map { |name, type| "#{name} #{type}" }.join(", ")
+      if column_definitions.empty?
+        ActiveRecord::Base.connection.execute <<-SQL.squish
+          CREATE TEMPORARY IF NOT EXISTS #{@table_name} (
+            id SERIAL PRIMARY KEY
+          );
+        SQL
+      else
+        ActiveRecord::Base.connection.execute <<-SQL.squish
+          CREATE TEMPORARY TABLE #{@table_name} (
+            id SERIAL PRIMARY KEY,
+            #{column_definitions}
+          );
+        SQL
+      end
+    end
+  end
+end

data/lib/temp_table/fetch.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TempTable
+  class Fetch
+    attr_accessor :table_name, :conditions
+
+    def initialize(table_name, conditions = nil)
+      @table_name = table_name
+      @conditions = conditions
+    end
+
+    def perform
+      query = "SELECT * FROM #{table_name}"
+
+      if conditions.present?
+        condition_strings = conditions.map do |column, value|
+          "#{column} = #{ActiveRecord::Base.connection.quote(value)}"
+        end
+        query += " WHERE #{condition_strings.join(' AND ')}"
+      end
+
+      ActiveRecord::Base.connection.execute(query).to_a
+    end
+  end
+end

data/lib/temp_table/insert.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TempTable
+  class Insert
+    attr_accessor :table_name, :data
+
+    def initialize(table_name, data)
+      super()
+      @table_name = table_name
+      @data = data
+    end
+
+    def perform
+      data.each do |row|
+        column_names = row.keys.join(", ")
+        values = row.values.map do |value|
+          if value.is_a?(Array)
+            ActiveRecord::Base.connection.quote(value.to_json)
+          else
+            ActiveRecord::Base.connection.quote(value)
+          end
+        end
+        ActiveRecord::Base.connection.execute <<-SQL.squish
+          INSERT INTO #{@table_name} (#{column_names})
+          VALUES (#{values.join(', ')});
+        SQL
+      end
+    end
+  end
+end

data/lib/temp_table/insert_row_from_original.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TempTable
+  class InsertRowFromOriginal
+    attr_accessor :table_name, :original_table_name, :original_id
+
+    def initialize(original_table_name, original_id, table_name)
+      super()
+      @original_table_name = original_table_name
+      @table_name = table_name
+      @original_id = original_id
+    end
+
+    def perform
+      result = ActiveRecord::Base.connection.execute <<-SQL.squish
+        INSERT INTO #{@table_name} (original_id, #{column_names})
+        SELECT id, #{column_names} FROM #{@original_table_name}
+        WHERE id = #{ActiveRecord::Base.connection.quote(original_id)}
+        RETURNING id;
+      SQL
+
+      result.getvalue(0, 0)
+    end
+
+    private
+
+    def column_names
+      ActiveRecord::Base.connection.columns(@original_table_name).reject { |c| c.name == "id" }.map(&:name).join(", ")
+    end
+  end
+end

data/lib/temp_table/insert_row_from_reference.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TempTable
+  class InsertRowFromReference
+    attr_accessor :table_name, :original_table_name, :reference_column, :reference_id, :data, :original_id
+
+    def initialize(reference_column, reference_id, data, original_table_name, table_name)
+      super()
+      @original_table_name = original_table_name
+      @table_name = table_name
+      @original_id = data.id
+      @reference_column = reference_column
+      @reference_id = reference_id
+      @data = data
+    end
+
+    def perform
+      formated_data = []
+      formated_data << data.attributes
+      formated_data[0]["original_id"] = original_id
+      formated_data[0][reference_column] = reference_id
+      InsertService.new(table_name, formated_data).perform
+    end
+  end
+end

data/lib/temp_table/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TempTable
+  VERSION = "0.1.0"
+end

data/lib/temp_table.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "temp_table/version"
+
+module TempTable
+  class Error < StandardError; end
+  def self.fetch(table_name, conditions = nil)
+    TempTable::Fetch.new(table_name, conditions).perform
+  end
+
+  def self.insert(table_name, data)
+    TempTable::Insert.new(table_name, data).perform
+  end
+
+  def self.insert_row_from_original(original_table_name, original_id, table_name)
+    TempTable::InsertRowFromOriginal.new(original_table_name, original_id, table_name).perform
+  end
+
+  def self.insert_row_from_reference(reference_column, reference_id, data, original_table_name, table_name)
+    TempTable::InsertRowFromReferenceService.new(reference_column, reference_id, data, original_table_name, table_name).perform
+  end
+
+  def self.create(table_name, columns)
+    TempTable::Create.new(table_name, columns).perform
+  end
+
+  def self.copy(original_table_name, table_name, extra_columns = nil)
+    TempTable::Copy.new(original_table_name, table_name, extra_columns = nil).perform
+  end
+end

data/sig/temp_table.rbs

@@ -0,0 +1,4 @@
+module TempTable
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: temp_table
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shesh Nath Goswami
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-10-27 00:00:00.000000000 Z
+dependencies: []
+description: You can create temporary tables using this gem to store data temporarily
+  until the user's session is active.
+email:
+- sheshwork08@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/temp_table.rb
+- lib/temp_table/copy.rb
+- lib/temp_table/create.rb
+- lib/temp_table/fetch.rb
+- lib/temp_table/insert.rb
+- lib/temp_table/insert_row_from_original.rb
+- lib/temp_table/insert_row_from_reference.rb
+- lib/temp_table/version.rb
+- sig/temp_table.rbs
+homepage: https://github.com/Shesh-08/temp-table
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Shesh-08/temp-table
+  source_code_uri: https://github.com/Shesh-08/temp-table
+  changelog_uri: https://github.com/Shesh-08/temp-table/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key: 
+specification_version: 4
+summary: To create temporary tables.
+test_files: []