mysql_framework 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 889fe8ccc0b85df3fe457ceeacaf4ac66a8953fe6d68a62a066d0700c26d05fc
+  data.tar.gz: 619ace891bdf1d809774628ab8322298cb019ffa92d260467a13835fff4359d3
+SHA512:
+  metadata.gz: a6303e0423b54b92e7bf02dcd651a9da14b6a707b6848e046221ea769428e6633308da95389a83a16c1bc26343fcb106b15cb75cc1d79b2ee29c6c4cfe26c07b
+  data.tar.gz: 9f4c4372b49495c9660e269eec2eec9d3df901d15c4566c5694c2f463453eeeeb2a0f1eabd68e145aabf0d007249bdb1e5a1a963ddb942be4742544725a2b7a0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dynamodb_framework"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mysql_framework.rb

@@ -0,0 +1,15 @@
+require 'mysql2'
+require 'redlock'
+
+require_relative 'mysql_framework/connector'
+require_relative 'mysql_framework/logger'
+require_relative 'mysql_framework/scripts'
+require_relative 'mysql_framework/sql_column'
+require_relative 'mysql_framework/sql_condition'
+require_relative 'mysql_framework/sql_query'
+require_relative 'mysql_framework/sql_table'
+require_relative 'mysql_framework/version'
+
+module MysqlFramework
+
+end

data/lib/mysql_framework/connector.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  class Connector
+    def initialize(options = {})
+      @connection_pool = ::Queue.new
+
+      @options = default_options.merge(options)
+
+      Mysql2::Client.default_query_options.merge!(symbolize_keys: true, cast_booleans: true)
+    end
+
+    # This method is called to fetch a client from the connection pool or create a new client if no idle clients
+    # are available.
+    def check_out
+      @connection_pool.pop(true)
+    rescue StandardError
+      Mysql2::Client.new(@options)
+    end
+
+    # This method is called to check a client back in to the connection when no longer needed.
+    def check_in(client)
+      @connection_pool.push(client)
+    end
+
+    # This method is called to use a client from the connection pool.
+    def with_client
+      client = check_out
+      yield client
+    ensure
+      check_in(client) unless client.nil?
+    end
+
+    # This method is called to execute a prepared statement
+    def execute(query)
+      with_client do |client|
+        statement = client.prepare(query.sql)
+        statement.execute(*query.params)
+      end
+    end
+
+    # This method is called to execute a query
+    def query(query_string)
+      with_client { |client| client.query(query_string) }
+    end
+
+    # This method is called to execute a query which will return multiple result sets in an array
+    def query_multiple_results(query_string)
+      with_client do |client|
+        result = []
+        result << client.query(query_string).to_a
+        result << client.store_result&.to_a while client.next_result
+        result.compact
+      end
+    end
+
+    # This method is called to use a client within a transaction
+    def transaction
+      raise ArgumentError, 'No block was given' unless block_given?
+
+      with_client do |client|
+        begin
+          client.query('BEGIN')
+          yield client
+          client.query('COMMIT')
+        rescue StandardError => e
+          client.query('ROLLBACK')
+          raise e
+        end
+      end
+    end
+
+    def default_options
+      {
+        host:      ENV.fetch('MYSQL_HOST'),
+        port:      ENV.fetch('MYSQL_PORT'),
+        database:  ENV.fetch('MYSQL_DATABASE'),
+        username:  ENV.fetch('MYSQL_USERNAME'),
+        password:  ENV.fetch('MYSQL_PASSWORD'),
+        reconnect: true
+      }
+    end
+  end
+end

data/lib/mysql_framework/logger.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module MysqlFramework
+  def self.logger
+    return @@logger
+  end
+
+  def self.set_logger(logger)
+    @@logger = logger
+  end
+
+  MysqlFramework.set_logger(Logger.new(STDOUT))
+end

data/lib/mysql_framework/scripts.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'scripts/base'
+require_relative 'scripts/manager'
+require_relative 'scripts/table'

data/lib/mysql_framework/scripts/base.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  module Scripts
+    class Base
+      def partitions
+        ENV.fetch('MYSQL_PARTITIONS', '500').to_i
+      end
+
+      def database_name
+        @database_name ||= ENV.fetch('MYSQL_DATABASE')
+      end
+
+      def identifier
+        raise NotImplementedError if @identifier.nil?
+        @identifier
+      end
+
+      def apply
+        raise NotImplementedError
+      end
+
+      def rollback
+        raise NotImplementedError
+      end
+
+      def generate_partition_sql
+        (1..partitions).each_with_index.map { |_, i| "PARTITION p#{i} VALUES IN (#{i})" }.join(",\n\t")
+      end
+
+      def self.descendants
+        ObjectSpace.each_object(Class).select { |klass| klass < self }
+      end
+
+      def tags
+        []
+      end
+
+      def update_procedure(proc_name, proc_file)
+        mysql_connector.transaction do
+          mysql_connector.query(<<~SQL)
+            DROP PROCEDURE IF EXISTS #{proc_name};
+          SQL
+
+          proc_sql = File.read(proc_file)
+
+          mysql_connector.query(proc_sql)
+        end
+      end
+
+      private
+
+      def mysql_connector
+        @mysql_connector ||= MysqlFramework::Connector.new
+      end
+    end
+  end
+end

data/lib/mysql_framework/scripts/manager.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  module Scripts
+    class Manager
+      def execute
+        lock_manager.lock(self.class, 2000) do |locked|
+          raise unless locked
+
+          initialize_script_history
+
+          last_executed_script = retrieve_last_executed_script
+
+          mysql_connector.transaction do
+            pending_scripts = calculate_pending_scripts(last_executed_script)
+            MysqlFramework.logger.info { "[#{self.class}] - #{pending_scripts.length} pending data store scripts found." }
+
+            pending_scripts.each { |script| apply(script) }
+          end
+
+          MysqlFramework.logger.info { "[#{self.class}] - Migration script execution complete." }
+        end
+      end
+
+      def apply_by_tag(tags)
+        lock_manager.lock(self.class, 2000) do |locked|
+          raise unless locked
+
+          initialize_script_history
+
+          mysql_connector.transaction do
+            pending_scripts = calculate_pending_scripts(0)
+            MysqlFramework.logger.info { "[#{self.class}] - #{pending_scripts.length} pending data store scripts found." }
+
+            pending_scripts.reject { |script| (script.tags & tags).empty? }.sort_by(&:identifier)
+              .each { |script| apply(script) }
+          end
+
+          MysqlFramework.logger.info { "[#{self.class}] - Migration script execution complete." }
+        end
+      end
+
+      def drop_all_tables
+        drop_script_history
+        all_tables.each { |table| drop_table(table) }
+      end
+
+      def retrieve_last_executed_script
+        MysqlFramework.logger.info { "[#{self.class}] - Retrieving last executed script from history." }
+
+        result = mysql_connector.query(<<~SQL)
+          SELECT `identifier` FROM #{migration_table_name} ORDER BY `identifier` DESC
+        SQL
+
+        if result.each.to_a.length.zero?
+          0
+        else
+          Integer(result.first[:identifier])
+        end
+      end
+
+      def initialize_script_history
+        MysqlFramework.logger.info { "[#{self.class}] - Initializing script history." }
+
+        mysql_connector.query(<<~SQL)
+          CREATE TABLE IF NOT EXISTS #{migration_table_name} (
+            `identifier` CHAR(15) NOT NULL,
+            `timestamp` DATETIME NULL DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY (`identifier`),
+            UNIQUE INDEX `identifier_UNIQUE` (`identifier` ASC)
+          )
+        SQL
+      end
+
+      def calculate_pending_scripts(last_executed_script)
+        MysqlFramework.logger.info { "[#{self.class}] - Calculating pending data store scripts." }
+
+        MysqlFramework::Scripts::Base.descendants.map(&:new)
+          .select { |script| script.identifier > last_executed_script }.sort_by(&:identifier)
+      end
+
+      def table_exists?(table_name)
+        result = mysql_connector.query(<<~SQL)
+          SHOW TABLES LIKE '#{table_name}'
+        SQL
+        result.count == 1
+      end
+
+      def drop_script_history
+        drop_table(migration_table_name)
+      end
+
+      def drop_table(table_name)
+        mysql_connector.query(<<~SQL)
+          DROP TABLE IF EXISTS #{table_name}
+        SQL
+      end
+
+      def all_tables
+        self.class.all_tables
+      end
+
+      def self.all_tables
+        @all_tables ||= []
+      end
+
+      private
+
+      def mysql_connector
+        @mysql_connector ||= MysqlFramework::Connector.new
+      end
+
+      def lock_manager
+        @lock_manager ||= Redlock::Client.new([ENV.fetch('REDIS_URL')])
+      end
+
+      def database
+        @database ||= ENV.fetch('MYSQL_DATABASE')
+      end
+
+      def migration_table_name
+        return @migration_table_name if @migration_table_name
+
+        @migration_table_name = "`#{database}`.`migration_script_history`"
+      end
+
+      def apply(script)
+        MysqlFramework.logger.info { "[#{self.class}] - Applying script: #{script}." }
+
+        script.apply
+        mysql_connector.query(<<~SQL)
+          INSERT INTO #{migration_table_name} (`identifier`, `timestamp`) VALUES ('#{script.identifier}', NOW())
+        SQL
+      end
+    end
+  end
+end

data/lib/mysql_framework/scripts/table.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  module Scripts
+    module Table
+      def register_table(name)
+        MysqlFramework::Scripts::Manager.all_tables << name
+      end
+    end
+  end
+end

data/lib/mysql_framework/sql_column.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+  # This class is used to represent a sql column within a table
+  class SqlColumn
+    def initialize(table:, column:)
+      @table = table
+      @column = column
+    end
+
+    def to_s
+      "`#{@table}`.`#{@column}`"
+    end
+
+    def to_sym
+      @column.to_sym
+    end
+
+    # This method is called to create a equals (=) condition for this column.
+    def eq(value)
+      SqlCondition.new(column: to_s, comparison: '=', value: value)
+    end
+
+    # This method is called to create a not equal (<>) condition for this column.
+    def not_eq(value)
+      SqlCondition.new(column: to_s, comparison: '<>', value: value)
+    end
+
+    # This method is called to create a greater than (>) condition for this column.
+    def gt(value)
+      SqlCondition.new(column: to_s, comparison: '>', value: value)
+    end
+
+    # This method is called to create a greater than or equal (>=) condition for this column.
+    def gte(value)
+      SqlCondition.new(column: to_s, comparison: '>=', value: value)
+    end
+
+    # This method is called to create a less than (<) condition for this column.
+    def lt(value)
+      SqlCondition.new(column: to_s, comparison: '<', value: value)
+    end
+
+    # This method is called to create a less than or equal (<=) condition for this column.
+    def lte(value)
+      SqlCondition.new(column: to_s, comparison: '<=', value: value)
+    end
+
+    # This method is called to generate an alias statement for this column.
+    def as(name)
+      "#{self} as `#{name}`"
+    end
+  end
+end

data/lib/mysql_framework/sql_condition.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+# This class is used to represent a Sql Condition for a column.
+  class SqlCondition
+    # This method is called to get the value of this condition for prepared statements.
+    attr_reader :value
+
+    def initialize(column:, comparison:, value:)
+      @column = column
+      @comparison = comparison
+      @value = value
+    end
+
+    # This method is called to get the condition as a string for a sql prepared statement
+    def to_s
+      "#{@column} #{@comparison} ?"
+    end
+  end
+end