mimi-db 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67ce0ef4ee1bf56935424d8d4ea78fb43a1b502b
-  data.tar.gz: bfca6acb463411916d0199a8c7cae5b657b792db
+  metadata.gz: eec89d0a86280f91bedbfb6593261807397f6ac1
+  data.tar.gz: e769745b46e668134cace4e827bd434a4cae4287
 SHA512:
-  metadata.gz: 7eb1380db55e093e71b5a394bebb9667c6e1e028805a9543fdc0c3a187309e8dfb51750c196a2fb7611352449e034753d93e2933db17356262a84017a3f11498
-  data.tar.gz: 0b1902f9fb5b5456cef3028175ac35e7c964f44cf3ea180a652592070bbda7db1d0cc89414c59467f577335542f603ad217fd5537005efff1d3308320eb1b478
+  metadata.gz: 0e330af2c6335bbab54cf6f8eb91416590adfa55dfbc5d3c2dc879b062e66cd67bd90e99b2d8b707c8f41724f12e0f4a182169572e49a94633d1ae168b012e56
+  data.tar.gz: aecc5b570e761ab14b13de6c19b50f65297ca46ac0d2be23404233f6b705add4c6ddaacfa4e95f97618d380c8b328c25bf2940c7c06015ecf70bf0cc2c97a518

data/examples/my_app.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+puts "Requiring mimi/db, mimi/logger"
 require 'mimi/db'
 require 'mimi/logger'
+puts "DONE"
 
 CONFIG = {
   db_adapter: 'sqlite3',
@@ -12,18 +14,7 @@ CONFIG = {
 Mimi::DB.configure(CONFIG)
 Mimi::DB.start
 
-class MyModel < ActiveRecord::Base
-  field :id, as: :integer, primary_key: true, not_null: true, autoincrement: true
-  field :name, as: :string, limit: 64
-  field :code, as: :string, default: -> { random_code }
-  field :value, as: :decimal, precision: 10, scale: 3
-
-  index :name
-
-  def self.random_code
-    SecureRandom.hex(16)
-  end
-end # class MyModel
+require_relative 'my_model'
 
 Mimi::DB.create_if_not_exist! # creates configured database
 Mimi::DB.update_schema!

data/examples/my_app_2.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+puts "Requiring mimi/db, mimi/logger"
+require 'mimi/db'
+require 'mimi/logger'
+puts "DONE"
+
+CONFIG = {
+  db_adapter: 'sqlite3',
+  db_database: '../tmp/my_app_db',
+  db_log_level: :debug
+}.freeze
+
+Mimi::DB.configure(CONFIG)
+Mimi::DB.start
+
+require_relative 'my_model'
+
+require 'pp'
+pp Mimi::DB.diff_schema

data/examples/my_model.rb

@@ -0,0 +1,13 @@
+class MyModel < Mimi::DB::Model
+  field :id, as: :integer, primary_key: true, not_null: true, auto_increment: true
+
+  field :name, as: :string, limit: 64
+  field :code, as: :blob, default: -> { random_code }
+  field :value, as: :decimal, precision: 10, scale: 3
+
+  index :name
+
+  def self.random_code
+    SecureRandom.hex(16)
+  end
+end # class MyModel

data/lib/mimi/db/dictate/dsl.rb

@@ -52,8 +52,8 @@ module Mimi
         # Sets up a default as a block/Proc
         #
         def field_setup_default(name, block)
-          before_validation on: :create do
-            self.send :"#{name}=", block.call
+          self.before_validation do
+            send :"#{name}=", instance_exec(&block) unless send(name.to_sym)
           end
         end
       end # module DSL

data/lib/mimi/db/dictate/explorer.rb

@@ -9,10 +9,11 @@ module Mimi
         #
         # Returns nil if the DB table does not exist.
         #
-        # @param table_name [String]
+        # @param table_name [String,Symbol]
         # @return [Mimi::DB::Dictate::SchemaDefinition,nil]
         #
         def self.discover_schema(table_name)
+          table_name = table_name.to_sym
           return nil unless connection.tables.include?(table_name)
           sd = Mimi::DB::Dictate::SchemaDefinition.new(table_name)
           discover_schema_columns(sd)
@@ -26,19 +27,20 @@ module Mimi
         # @param schema_definition [Mimi::DB::Dictate::SchemaDefinition]
         #
         def self.discover_schema_columns(schema_definition)
-          columns = connection.columns(schema_definition.table_name)
-          pk = connection.primary_key(schema_definition.table_name)
-          columns.each do |c|
+          columns = connection.schema(schema_definition.table_name).to_h
+          columns.each do |name, c|
             params = {
-              as: c.type,
-              limit: c.limit,
-              primary_key: (pk == c.name),
-              auto_increment: false, # FIXME: SQLite does not report autoincremented fields
-              not_null: !c.null,
-              default: c.default,
-              sql_type: c.sql_type
+              as: c[:type],
+              type: c[:type],
+              size: c[:max_length],
+              primary_key: c[:primary_key],
+              auto_increment: c[:auto_increment], # FIXME: SQLite does not report autoincremented fields
+              null: c[:allow_null],
+              db_default: c[:default],
+              default: c[:default],
+              db_type: c[:db_type]
             }
-            schema_definition.field(c.name, params)
+            schema_definition.field(name, params)
           end
         end
         private_class_method :discover_schema_columns
@@ -49,23 +51,35 @@ module Mimi
         # @param schema_definition [Mimi::DB::Dictate::SchemaDefinition]
         #
         def self.discover_schema_indexes(schema_definition)
-          indexes = connection.indexes(schema_definition.table_name)
-          pk = connection.primary_key(schema_definition.table_name)
-          indexes.each do |idx|
+          indexes = connection.indexes(schema_definition.table_name).to_h
+          pk = discover_primary_key(schema_definition.table_name)
+          indexes.each do |idx_name, idx_data|
             params = {
-              name: idx.name,
-              primary_key:  idx.columns == [pk],
-              unique: idx.unique
+              name: idx_name,
+              primary_key:  idx_data[:columns] == pk,
+              unique: idx_data[:unique]
             }
-            schema_definition.index(idx.columns, params)
+            schema_definition.index(idx_data[:columns], params)
           end
         end
         private_class_method :discover_schema_indexes
 
+        # Discovers primary key of an existing DB table
+        #
+        # @private
+        # @param table_name [String,Symbol]
+        #
+        # @return [Array<Symbol>]
+        #
+        def self.discover_primary_key(table_name)
+          s = connection.schema(table_name).to_h
+          s.keys.select { |name| s[name][:primary_key] }
+        end
+
         # Returns ActiveRecord DB connection
         #
         def self.connection
-          ActiveRecord::Base.connection
+          Mimi::DB.connection
         end
       end # module Explorer
     end # module Dictate

data/lib/mimi/db/dictate/migrator.rb

@@ -22,12 +22,12 @@ module Mimi
         # @param options [Hash]
         #
         def initialize(table_name, options)
-          @table_name = table_name
+          @table_name = table_name.to_sym
           @options = DEFAULTS.merge(options.dup)
-          @from_schema = self.class.db_schema_definition(table_name.to_s)
-          @to_schema   = Mimi::DB::Dictate.schema_definitions[table_name.to_s]
+          @from_schema = self.class.db_schema_definition(@table_name)
+          @to_schema   = Mimi::DB::Dictate.schema_definitions[@table_name]
           if from_schema.nil? && to_schema.nil?
-            raise "Failed to migrate '#{table_name}', no DB or target schema found"
+            raise "Failed to migrate '#{@table_name}', no DB or target schema found"
           end
         end
 
@@ -36,7 +36,7 @@ module Mimi
         end
 
         def db_connection
-          ActiveRecord::Base.connection
+          Mimi::DB.connection
         end
 
         # Returns true if the Migrator is configured to do a dry run (no actual changes to DB)
@@ -54,9 +54,11 @@ module Mimi
         end
 
         def run!
-          run_drop_table! if from_schema && to_schema.nil?
-          run_change_table! if from_schema && to_schema
-          run_create_table! if from_schema.nil? && to_schema
+          db_ddl_transaction do
+            run_drop_table! if from_schema && to_schema.nil?
+            run_change_table! if from_schema && to_schema
+            run_create_table! if from_schema.nil? && to_schema
+          end
           self.class.reset_db_schema_definition!(table_name)
         end
 
@@ -110,15 +112,13 @@ module Mimi
         def run_create_table!
           columns    = to_schema.columns.values
           column_pk  = to_schema.primary_key
-          params =
-            column_pk.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
 
           # issue CREATE TABLE with primary key field
           logger.info "- CREATE TABLE: #{table_name}"
-          logger.info "-- add column: #{table_name}.#{column_pk.name} (#{params})"
+          logger.info "-- add column: #{table_name}.#{column_pk}"
           unless dry_run?
-            db_connection.create_table(table_name, id: false) do |t|
-              t.column column_pk.name, column_pk.type, column_pk.to_ar_params
+            db_connection.create_table(table_name) do |_|
+              column column_pk.name, column_pk.sequel_type, column_pk.to_sequel_params
             end
           end
 
@@ -130,28 +130,34 @@ module Mimi
         def drop_column!(table_name, column_name)
           logger.info "-- drop column: #{table_name}.#{column_name}"
           return if dry_run? || !destructive?(:columns)
-          db_connection.remove_column(table_name, column_name)
+          db_connection.drop_column(table_name, column_name)
         end
 
         def change_column!(table_name, column)
-          params = column.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
-          logger.info "-- change column: #{table_name}.#{column.name} (#{params})"
+          logger.info "-- change column: #{table_name}.#{column}"
           return if dry_run?
-          db_connection.change_column(table_name, column.name, column.type, column.to_ar_params)
+          db_connection.alter_table(table_name) do
+            set_column_type column.name, column.sequel_type, column.to_sequel_params.except(:default, :null)
+            set_column_default column.name, column.params[:default]
+            if column.to_sequel_params[:null]
+              set_column_allow_null column.name
+            else
+              set_column_not_null column.name
+            end
+          end
         end
 
         def add_column!(table_name, column)
-          params = column.params.select { |_, v| v }.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
-          logger.info "-- add column: #{table_name}.#{column.name} (#{params})"
+          logger.info "-- add column: #{table_name}.#{column}"
           return if dry_run?
-          db_connection.add_column(table_name, column.name, column.type, column.to_ar_params)
+          db_connection.add_column(table_name, column.name, column.sequel_type, column.to_sequel_params)
         end
 
         def drop_index!(table_name, idx)
           idx_column_names = idx.columns.join(', ')
           logger.info "-- drop index: #{idx.name} on #{table_name}(#{idx_column_names})"
           return if dry_run?
-          db_connection.remove_index(table_name, column: idx.columns)
+          db_connection.drop_index(table_name, idx.columns)
         end
 
         def add_index!(table_name, idx)
@@ -161,6 +167,14 @@ module Mimi
           return if dry_run?
           db_connection.add_index(table_name, idx.columns, idx.params)
         end
+
+        def db_ddl_transaction(&_block)
+          supports_transactional_ddl =
+            db_connection.respond_to?(:supports_transactional_ddl?) &&
+            db_connection.supports_transactional_ddl?
+          return yield unless supports_transactional_ddl
+          db_connection.transaction { yield }
+        end
       end # class Migrator
     end # module Dictate
   end # module DB

data/lib/mimi/db/dictate/schema_definition.rb

@@ -12,28 +12,48 @@ module Mimi
           @indexes = []
         end
 
+        # Declares a field
+        #
+        # Example:
+        #   field :s1, as: :string
+        #   field :s2, type: :string, size: 64
+        #   field :v1, as: :decimal, size: 10      # precision: 10
+        #   field :v2, as: :decimal, size: [10, 3] # precision: 10, scale: 3
+        #
+        #
         def field(name, opts)
-          name = name.to_s
+          name = name.to_sym
           raise "Cannot redefine field :#{name}" if @columns[name]
-          if primary_key && (opts[:primary_key] || opts[:as] == :primary_key)
+          opts_type = opts[:type] || opts[:as]
+          if primary_key && (opts[:primary_key] || opts_type == :primary_key)
             raise "Cannot redefine primary key (:#{primary_key.name}) with :#{name}"
           end
           @columns[name] = Column.new(name, opts)
         end
 
+        # Declares an index
+        #
+        # Example:
+        #   index :name
+        #   index [:first_name, :last_name]
+        #   index :ref_code, unique: true
+        #
+        # @param columns [String,Symbol,Array<String,Symbol>] columns to index on
+        # @param opts [Hash] index parameters (:unique, :name etc)
+        #
         def index(columns, opts)
           case columns
           when String, Symbol
-            columns = [columns.to_s]
+            columns = [columns.to_sym]
           when Array
             unless columns.all? { |c| c.is_a?(String) || c.is_a?(Symbol) }
               raise "Invalid column reference in index definition [#{columns}]"
             end
-            columns = columns.map(&:to_s)
+            columns = columns.map(&:to_sym)
           else
             raise 'Invalid columns argument to .index'
           end
-          if columns == [primary_key]
+          if columns == [primary_key.name]
             # TODO: warn the primary key index is ignored
           end
           @indexes << Index.new(columns, opts)
@@ -57,24 +77,25 @@ module Mimi
           }
         end
 
+        # Represents a column in schema definition
+        #
         class Column
-          DEFAULTS = {
-            as: :string,
-            limit: nil,
-            primary_key: false,
-            auto_increment: false,
-            not_null: false,
-            default: nil,
-            sql_type: nil
-          }.freeze
+          DEFAULT_TYPE = :string
 
-          attr_reader :name, :type, :params
+          attr_reader :name, :type, :sequel_type, :params
 
+          # Creates a Column object
+          #
+          # @param name [String,Symbol]
+          # @param opts [Hash]
+          #
           def initialize(name, opts)
-            @name = name
-            @type = opts[:as] || DEFAULTS[:as]
-            type_defaults = Mimi::DB::Dictate.type_defaults(type)
-            @params = DEFAULTS.merge(type_defaults).merge(opts)
+            @name = name.to_sym
+            @params = opts.dup
+            @params[:type] ||= @params[:as] || DEFAULT_TYPE
+            @params = Mimi::DB::Dictate::TypeDefaults.infer_params(@params)
+            @type = @params[:type]
+            @sequel_type = @params[:sequel_type]
           end
 
           def to_h
@@ -84,28 +105,35 @@ module Mimi
             }
           end
 
-          def to_ar_params
-            p = params.dup
-            p[:null] = !p[:not_null]
+          def to_sequel_params
+            p = params.dup.except(:type, :as)
+            p[:null] = !p[:not_null] if p.key?(:not_null)
             p
           end
 
+          def to_s
+            public_params = params.only(
+              :type, :primary_key, :auto_increment, :not_null, :default, :size
+            ).select { |_, v| v }.to_h
+            public_params = public_params.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+            "#{name}(#{public_params})"
+          end
+
           def ==(other)
             unless other.name == name
               raise ArgumentError, 'Cannot compare columns with different names'
             end
             equal = true
-            equal &&= params[:as] == other.params[:as]
-            equal &&= params[:limit] == other.params[:limit]
+            equal &&= params[:db_type] == other.params[:db_type]
             equal &&= params[:primary_key] == other.params[:primary_key]
-            # FIXME: auto_increment ignored
             equal &&= params[:not_null] == other.params[:not_null]
-            equal &&= params[:default].to_s == other.params[:default].to_s
-            # FIXME: sql_type ignored
+            equal &&= params[:db_default].to_s == other.params[:db_default].to_s
             equal
           end
         end # class Column
 
+        # Represents an index in schema definition
+        #
         class Index
           DEFAULTS = {
             unique: false
@@ -113,9 +141,14 @@ module Mimi
 
           attr_reader :name, :columns, :params
 
+          # Creates an Index object
+          #
+          # @param columns [Array<String,Symbol>]
+          # @param params [Hash]
+          #
           def initialize(columns, params)
             @name = params[:name]
-            @columns = columns
+            @columns = columns.map(&:to_sym)
             @params = DEFAULTS.merge(params)
           end
 

data/lib/mimi/db/dictate/schema_diff.rb

@@ -5,11 +5,6 @@ module Mimi
     module Dictate
       module SchemaDiff
         DEFAULT_OPTIONS = {
-          # Force updates on fields defined as :primary_key type.
-          # If disabled, the field definition will only be used in 'CREATE TABLE'.
-          # (forced updates on :primary_key break on Postgres, at least)
-          #
-          force_primary_key: false
         }.freeze
 
         #
@@ -18,7 +13,7 @@ module Mimi
         # @return [Hash] :columns, :indexes => :from, :to
         #
         def self.diff(from, to, opts = {})
-          options = DEFAULT_OPTIONS.merge(opts)
+          _options = DEFAULT_OPTIONS.merge(opts)
           result = { table_name: from.table_name, columns: {}, indexes: {} }
           all_column_names = (from.columns.values.map(&:name) + to.columns.values.map(&:name)).uniq
           all_column_names.each do |c|

data/lib/mimi/db/dictate/type_defaults.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Mimi
+  module DB
+    module Dictate
+      module TypeDefaults
+
+        # Constructs a Proc that returns "<type>" or "<type>(n)" depending on whether the size is provided
+        #
+        DEF_OPT_SIZE_PROC = lambda do |type, default_size_suffix = ''|
+          ->(p) { p[:size] ? { db_type: "#{type}(#{p[:size]})" } : { db_type: type + default_size_suffix } }
+        end
+
+        # Produces a "string" or "string(n)" depending on whether the size is provided
+        #
+        TYPE_STRING_PROC = DEF_OPT_SIZE_PROC.call('string')
+
+        # Produces an "integer" or "integer(n)" depending on whether size is provided
+        #
+        TYPE_INTEGER_PROC = DEF_OPT_SIZE_PROC.call('integer')
+
+        # Produces a "decimal", "decimal(p)" or "decimal(p,s)" depending on whether size is provided
+        #
+        TYPE_DECIMAL_PROC = lambda do |p|
+          p[:size] ? { db_type: "decimal(#{[*p[:size]].join(',')})" } : { db_type: 'decimal' }
+        end
+
+        # Produces a "decimal", "decimal(p)" or "decimal(p, s)" depending on whether size is provided
+        #
+        TYPE_SQLITE_DECIMAL_PROC = lambda do |p|
+          p[:size] ? { db_type: "decimal(#{[*p[:size]].join(', ')})" } : { db_type: 'decimal' }
+        end
+
+        # Produces a "numeric" or "numeric(p, s)" depending on whether size is provided
+        #
+        TYPE_POSTGRES_NUMERIC_PROC = lambda do |p|
+          if p[:size]
+            # p[:size] is either a number (precision) or an array (precision, scale)
+            p1, p2 = [*p[:size]]
+            { db_type: "numeric(#{p1},#{p2 || 0})" }
+          else
+            { db_type: 'numeric' }
+          end
+        end
+
+        # Produces a "character varying" or "character varying(n)" depending on whether the size is provided
+        #
+        TYPE_POSTGRES_VARCHAR_PROC = lambda do |p|
+          if p[:size]
+            { db_type: "character varying(#{p[:size]})", sequel_type: :varchar }
+          else
+            { db_type: 'character varying(255)', sequel_type: :varchar }
+          end
+        end
+
+        # Type converters, accept Sequel type (field as: ...) as a key,
+        # return:
+        # * a Hash of field params or
+        # * a Proc returning a Hash of field params
+        #
+        TYPE_MAP = {
+          default: {
+          },
+          sqlite: {
+            bigint:    { db_type: 'bigint' },
+            integer:   TYPE_INTEGER_PROC,
+            int:       { db_type: 'integer', sequel_type: :integer },
+            smallint:  { db_type: 'smallint' },
+
+            decimal:   TYPE_SQLITE_DECIMAL_PROC,
+
+            string:    DEF_OPT_SIZE_PROC.call('string'),
+            varchar:   DEF_OPT_SIZE_PROC.call('varchar', '(255)'),
+            text:      { db_type: 'text' },
+
+            bytes:     { db_type: 'bytea', sequel_type: :bytea },
+            bytea:     { db_type: 'bytea' },
+            blob:      { db_type: 'blob' },
+
+            bool:      { db_type: 'bool', sequel_type: :bool },
+            boolean:   { db_type: 'bool', sequel_type: :bool },
+
+            date:      { db_type: 'date' },
+            timestamp: { db_type: 'timestamp' },
+            datetime:  { db_type: 'timestamp', sequel_type: :timestamp },
+
+            float:      { db_type: 'double precision' }
+          },
+          postgres: {
+            bigserial: { db_type: 'bigint', db_default: "nextval('tests_id_seq'::regclass)" },
+            bigint:    { db_type: 'bigint' },
+            integer:   { db_type: 'integer', sequel_type: :integer },
+            int:       { db_type: 'integer', sequel_type: :integer },
+            smallint:  { db_type: 'smallint' },
+
+            decimal:   TYPE_POSTGRES_NUMERIC_PROC,
+
+            string:    TYPE_POSTGRES_VARCHAR_PROC,
+            varchar:   TYPE_POSTGRES_VARCHAR_PROC,
+            text:      { db_type: 'text' },
+
+            bytes:     { db_type: 'bytea', sequel_type: :bytea },
+            bytea:     { db_type: 'bytea' },
+            blob:      { db_type: 'bytea', sequel_type: :bytea },
+
+            bool:      { db_type: 'boolean' },
+            boolean:   { db_type: 'boolean' },
+
+            date:      { db_type: 'date' },
+            timestamp: { db_type: 'timestamp without time zone' },
+            datetime:  { db_type: 'timestamp without time zone', sequel_type: :timestamp },
+
+            float:      { db_type: 'double precision' }
+          },
+          cockroachdb: {
+            bigserial: { db_type: 'bigint', db_default: 'unique_rowid()' },
+            bigint:    { db_type: 'bigint' },
+            integer:   { db_type: 'bigint' },
+            int:       { db_type: 'bigint', sequel_type: :integer },
+            smallint:  { db_type: 'bigint', sequel_type: :integer },
+
+            decimal:   { db_type: 'numeric' },
+
+            string:    { db_type: 'text', sequel_type: :string },
+            varchar:   { db_type: 'text', sequel_type: :string },
+            text:      { db_type: 'text' },
+
+            bytes:     { db_type: 'bytea' },
+            bytea:     { db_type: 'bytea', sequel_type: :bytes },
+            blob:      { db_type: 'bytea', sequel_type: :bytes },
+
+            bool:      { db_type: 'boolean' },
+            boolean:   { db_type: 'boolean' },
+
+            date:      { db_type: 'date' },
+            timestamp: { db_type: 'timestamp without time zone' },
+            datetime:  { db_type: 'timestamp without time zone', sequel_type: :timestamp },
+
+            float:      { db_type: 'double precision' }
+          }
+        }.freeze
+
+        #
+        # The method infers column params based on column definition
+        #
+        # @param params [Hash]
+        # @return [Hash]
+        #
+        def self.infer_params(params)
+          type = params[:type].to_sym
+          defaults = {
+            db_type: type.to_s,
+            sequel_type: type,
+            primary_key: !!params[:primary_key],
+            not_null: !!params[:primary_key],
+            db_default: params[:default]
+          }
+          adapter_name = Mimi::DB.sequel_config[:adapter]
+          raise "Failed to infer_params, adapter is not set: #{adapter_name}" unless adapter_name
+          inferred_params = TYPE_MAP[adapter_name.to_sym][type] || TYPE_MAP[:default][type] || {}
+          inferred_params = inferred_params.call(params) if inferred_params.is_a?(Proc)
+          defaults.merge(inferred_params).merge(params)
+        end
+      end # module TypeDefaults
+    end # module Dictate
+  end # module DB
+end # module Mimi