dm-is-reflective 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e05d37577ac7449933ee4680893d496c6ca138f
-  data.tar.gz: ff50451f50e9b1094db71272cbda92bb7476015a
+  metadata.gz: e0cf6d64d700dd5f9892573cc43a1d19eb3ba2cd
+  data.tar.gz: 7c7647fd2e0a7c917aaf4b035432cff3849ad828
 SHA512:
-  metadata.gz: eb614bb45b425c7d5cbdbeb9cbaa8b8acb34ff4492af861c277cdfb60c116ec5560504dd10402dbb492dfa7f5adbc441588f40e0bd3fd59fef29e7535c47d858
-  data.tar.gz: 9bc150a2c0da4b77af03cca23f2f7c8148d7196689e714c4e8544e6fb38d506c2257dc5f5b25fca74b620e20893c4192eadbc8d2430f1f40ab0f2f8ecccbf5bd
+  metadata.gz: f2551113619f6540170864bcb217550037d70e5f4887812c88501b8aa302174080b7244817596e47d45e7d9826b0d152a39cc040d352a2d7803795b33e5946b0
+  data.tar.gz: eb33bdb42e9c47d686a7f8cd99a8848f99260fa82053d751e070855de838f045aa4b146b5919fa469a77b9b8b3b71cfd1f7b9cbb59b658d37c2e6702e64c10f6

data/CHANGES.md

@@ -1,5 +1,9 @@
 # CHANGES
 
+## dm-is-reflective 1.3.1, 2013-05-22
+
+* Introduce `indices` method which would return all indices in the storage.
+
 ## dm-is-reflective 1.3.0, 2013-05-20
 
 * Warn instead of raising a TypeError if a datatype cannot be found.

data/README.md

@@ -80,6 +80,9 @@ end
 dm.storages
 # => ['users']
 
+# show all indices
+dm.indices('users') # [:id, {:unique_index => :users_pkey}]
+
 # there's no guarantee of the order in fields array
 User.fields
 # => [[:created_at,  DateTime, {:required => false}],

data/dm-is-reflective.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = "dm-is-reflective"
-  s.version = "1.3.0"
+  s.version = "1.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2013-05-20"
+  s.date = "2013-05-22"
   s.description = "DataMapper plugin that helps you manipulate an existing database.\nIt creates mappings between existing columns and model's properties."
   s.email = ["godfat (XD) godfat.org"]
   s.executables = ["dm-is-reflective"]

data/lib/dm-is-reflective/adapters/data_objects_adapter.rb

@@ -10,6 +10,12 @@ module DmIsReflective::DataObjectsAdapter
     storages # call the overrided method
   end
 
+  # returns all indices in the storage.
+  def indices storage
+    reflective_auto_load_adapter_extension
+    indices(storage) # call the overrided method
+  end
+
   # returns all fields, with format [[name, type, attrs]]
   #  e.g.
   #       [[:created_at,  DateTime, {:required => false}],
@@ -133,4 +139,12 @@ module DmIsReflective::DataObjectsAdapter
     Adapters.const_get(class_name).__send__(:include,
       DmIsReflective.const_get(class_name))
   end
+
+  def reflective_indices_hash key, idx_uni, idx_com
+    h = {}
+    h[:key]          = key     if key
+    h[:unique_index] = idx_uni if idx_uni
+    h[       :index] = idx_com if idx_com
+    h
+  end
 end

data/lib/dm-is-reflective/adapters/mysql_adapter.rb

@@ -6,53 +6,51 @@ module DmIsReflective::MysqlAdapter
     select('SHOW TABLES')
   end
 
-  private
-  # construct needed table metadata
-  def reflective_query_storage storage
-    sql_indices = <<-SQL
+  def indices storage
+    sql = <<-SQL
       SELECT column_name, index_name, non_unique
       FROM   `information_schema`.`statistics`
       WHERE  table_schema = ? AND table_name = ?
     SQL
 
-    sql_columns = <<-SQL
+    select(Ext::String.compress_lines(sql),
+      reflective_table_schema, storage).group_by(&:column_name).
+        inject({}) do |r, (column, idxs)|
+          primary = idxs.find{ |i| i.index_name == 'PRIMARY' }
+          primary.index_name = :"#{storage}_pkey" if primary
+          key                = !!primary
+          idx_uni, idx_com = idxs.partition{ |i| i.non_unique == 0 }.map{ |i|
+            if i.empty?
+              nil
+            elsif i.size == 1
+              i.first.index_name.to_sym
+            else
+              i.map{ |ii| ii.index_name.to_sym }
+            end
+          }
+
+          r[column.to_sym] = reflective_indices_hash(key, idx_uni, idx_com)
+          r
+        end
+  end
+
+  private
+  # construct needed table metadata
+  def reflective_query_storage storage
+    sql = <<-SQL
       SELECT column_name, column_key, column_default, is_nullable,
              data_type, character_maximum_length, extra, table_name
       FROM      `information_schema`.`columns`
       WHERE  table_schema = ? AND table_name = ?
     SQL
 
-    # TODO: can we fix this shit in dm-mysql-adapter?
-    path = (options[:path]     || options['path'] ||
-            options[:database] || options['database']).sub('/', '')
-
-    indices =
-    select(Ext::String.compress_lines(sql_indices), path, storage).
-      group_by(&:column_name)
-
-    select(Ext::String.compress_lines(sql_columns), path, storage).
-    map do |column|
-      if idx = indices[column.column_name]
-        idx_uni, idx_com = idx.partition{ |i| i.non_unique == 0 }.map{ |i|
-          if i.empty?
-            nil
-          elsif i.size == 1
-            i.first.index_name.to_sym
-          else
-            i.map{ |ii| ii.index_name.to_sym }
-          end
-        }
-      else
-        idx_uni, idx_com = nil
-      end
-
-      column.instance_eval <<-RUBY
-        def unique_index; #{idx_uni.inspect}; end
-        def index       ; #{idx_com.inspect}; end
-      RUBY
+    idxs = indices(storage)
 
-      column
-    end
+    select(Ext::String.compress_lines(sql),
+      reflective_table_schema, storage).map do |f|
+        f.define_singleton_method(:indices){ idxs[f.column_name.to_sym] }
+        f
+      end
   end
 
   def reflective_field_name field
@@ -63,15 +61,14 @@ module DmIsReflective::MysqlAdapter
     field.data_type
   end
 
-  def reflective_attributes field, attrs = {}
+  def reflective_attributes field, attrs={}
+    attrs.merge!(field.indices) if field.indices
+
     attrs[:serial] = true if field.extra == 'auto_increment'
 
     if field.column_key == 'PRI'
       attrs[:key] = true
       attrs[:unique_index] = :"#{field.table_name}_pkey"
-    else
-      attrs[:unique_index] = field.unique_index if field.unique_index
-      attrs[       :index] = field.       index if field.       index
     end
 
     attrs[:allow_nil] = field.is_nullable == 'YES'
@@ -99,4 +96,10 @@ module DmIsReflective::MysqlAdapter
     when /\w*TEXT/                        ; Property::Text
     end || super(primitive)
   end
+
+  def reflective_table_schema
+    # TODO: can we fix this shit in dm-mysql-adapter?
+    (options[:path]     || options['path'] ||
+     options[:database] || options['database']).sub('/', '')
+  end
 end

data/lib/dm-is-reflective/adapters/postgres_adapter.rb

@@ -11,9 +11,8 @@ module DmIsReflective::PostgresAdapter
     select(Ext::String.compress_lines(sql))
   end
 
-  private
-  def reflective_query_storage storage
-    sql_indices = <<-SQL
+  def indices storage
+    sql = <<-SQL
       SELECT a.attname, i.relname, ix.indisprimary, ix.indisunique
       FROM   pg_class t, pg_class i, pg_index ix, pg_attribute a
       WHERE  t.oid      = ix.indrelid
@@ -24,21 +23,10 @@ module DmIsReflective::PostgresAdapter
         AND  t.relname  = ?
     SQL
 
-    sql_columns = <<-SQL
-      SELECT column_name, column_default, is_nullable,
-             character_maximum_length, udt_name
-      FROM   "information_schema"."columns"
-      WHERE  table_schema = current_schema() AND table_name = ?
-    SQL
-
-    indices =
-    select(Ext::String.compress_lines(sql_indices), storage).
-      group_by(&:attname)
-
-    select(Ext::String.compress_lines(sql_columns), storage).map do |column|
-      if idx = indices[column.column_name]
-        is_key = !!idx.find{ |i| i.indisprimary }
-        idx_uni, idx_com = idx.partition{ |i| i.indisunique }.map{ |i|
+    select(Ext::String.compress_lines(sql), storage).group_by(&:attname).
+      inject({}) do |r, (column, idxs)|
+        key = !!idxs.find(&:indisprimary)
+        idx_uni, idx_com = idxs.partition(&:indisunique).map{ |i|
           if i.empty?
             nil
           elsif i.size == 1
@@ -47,18 +35,26 @@ module DmIsReflective::PostgresAdapter
             i.map{ |ii| ii.relname.to_sym }
           end
         }
-      else
-        is_key = false
-        idx_uni, idx_com = nil
+
+        r[column.to_sym] = reflective_indices_hash(key, idx_uni, idx_com)
+        r
       end
+  end
 
-      column.instance_eval <<-RUBY
-        def key?        ; #{is_key}         ; end
-        def unique_index; #{idx_uni.inspect}; end
-        def index       ; #{idx_com.inspect}; end
-      RUBY
+  private
+  def reflective_query_storage storage
+    sql = <<-SQL
+      SELECT column_name, column_default, is_nullable,
+             character_maximum_length, udt_name
+      FROM   "information_schema"."columns"
+      WHERE  table_schema = current_schema() AND table_name = ?
+    SQL
+
+    idxs = indices(storage)
 
-      column
+    select(Ext::String.compress_lines(sql), storage).map do |f|
+      f.define_singleton_method(:indices){ idxs[f.column_name.to_sym] }
+      f
     end
   end
 
@@ -70,18 +66,15 @@ module DmIsReflective::PostgresAdapter
     field.udt_name
   end
 
-  def reflective_attributes field, attrs = {}
+  def reflective_attributes field, attrs={}
     # strip data type
     if field.column_default
       field.column_default.gsub!(/(.*?)::[\w\s]*/, '\1')
     end
 
-    attrs[:serial] = true if field.column_default =~ /nextval\('\w+'\)/
-    attrs[:key]    = true if field.key?
-
-    attrs[:unique_index] = field.unique_index if field.unique_index
-    attrs[       :index] = field.       index if field.       index
+    attrs.merge!(field.indices) if field.indices
 
+    attrs[:serial] = true if field.column_default =~ /nextval\('\w+'\)/
     attrs[:allow_nil] = field.is_nullable == 'YES'
     # strip string quotation
     attrs[:default] = field.column_default.gsub(/^'(.*?)'$/, '\1') if

data/lib/dm-is-reflective/adapters/sqlite_adapter.rb

@@ -11,49 +11,46 @@ module DmIsReflective::SqliteAdapter
     select(Ext::String.compress_lines(sql))
   end
 
-  private
-  def reflective_query_storage storage
-    sql_indices = <<-SQL
+  def indices storage
+    sql = <<-SQL
       SELECT name, sql FROM sqlite_master
       WHERE type = 'index' AND tbl_name = ?
     SQL
 
-    indices = select(sql_indices, storage).inject({}){ |r, field|
-      columns    =   field.sql[/\(.+\)/].scan(/\w+/)
-      uniqueness = !!field.sql[/CREATE UNIQUE INDEX/]
+    select(Ext::String.compress_lines(sql), storage).inject({}){ |r, idx|
+      columns    = idx.sql[/\(.+\)/].scan(/\w+/)
+      uniqueness = !!idx.sql[/CREATE UNIQUE INDEX/]
 
       columns.each{ |c|
         type = if uniqueness then :unique_index else :index end
         r[c] ||= {:unique_index => [], :index => []}
-        r[c][type] << field.name
+        r[c][type] << idx.name.to_sym
       }
 
+      r
+    }.inject({}){ |r, (column, idxs)|
+      idx_uni, idx_com = [:unique_index, :index].map{ |type|
+        i = idxs[type]
+        if i.empty?
+          nil
+        elsif i.size == 1
+          i.first.to_sym
+        else
+          i.map(&:to_sym)
+        end
+      }
+      r[column.to_sym] = reflective_indices_hash(false, idx_uni, idx_com)
       r
     }
+  end
 
-    select('PRAGMA table_info(?)', storage).map{ |field|
-      if idx = indices[field.name]
-        idx_uni, idx_com = [:unique_index, :index].map{ |type|
-          i = idx[type]
-          if i.empty?
-            nil
-          elsif i.size == 1
-            i.first.to_sym
-          else
-            i.map(&:to_sym)
-          end
-        }
-      else
-        idx_uni, idx_com = nil
-      end
-
-      field.instance_eval <<-RUBY
-        def table_name  ; '#{storage}'      ; end
-        def index       ; #{idx_com.inspect}; end
-        def unique_index; #{idx_uni.inspect}; end
-      RUBY
-
-      field
+  private
+  def reflective_query_storage storage
+    idxs = indices(storage)
+    select('PRAGMA table_info(?)', storage).map{ |f|
+      f.define_singleton_method(:storage){ storage             }
+      f.define_singleton_method(:indices){ idxs[f.name.to_sym] }
+      f
     }
   end
 
@@ -65,16 +62,15 @@ module DmIsReflective::SqliteAdapter
     field.type.gsub(/\(\d+\)/, '')
   end
 
-  def reflective_attributes field, attrs = {}
+  def reflective_attributes field, attrs={}
+    attrs.merge!(field.indices) if field.indices
+
     if field.pk != 0
       attrs[:key]          = true
       attrs[:serial]       = true
-      attrs[:unique_index] = :"#{field.table_name}_pkey"
+      attrs[:unique_index] = :"#{field.storage}_pkey"
     end
 
-    attrs[:unique_index]   = field.unique_index if field.unique_index
-    attrs[       :index]   = field.       index if field.       index
-
     attrs[:allow_nil] = field.notnull == 0
     attrs[:default] = field.dflt_value[1..-2] if field.dflt_value
 

data/lib/dm-is-reflective/test.rb

@@ -69,6 +69,23 @@ end
 include Abstract
 
 shared :reflective do
+  def cat_indices
+    @cat_indices ||= begin
+      id = case DataMapper.repository.adapter.class.name
+           when 'DataMapper::Adapters::SqliteAdapter'
+             nil
+           else
+             [:id, {:unique_index => :abstract_cats_pkey, :key => true}]
+           end
+    [id                                                                    ,
+     [:super_user_id, {:unique_index => :unique_abstract_cats_usu          ,
+                              :index => :index_abstract_cats_su }]         ,
+     [      :user_id, {:unique_index => [:unique_abstract_cats_usu         ,
+                                         :unique_abstract_cats_u]}]        ].
+     compact
+    end
+  end
+
   def cat_fields
     @cat_fields ||=
     [[:id,         DataMapper::Property::Serial,
@@ -206,6 +223,10 @@ shared :reflective do
                 'abstract_super_users' => super_user_fields)
   end
 
+  should 'indices' do
+    sort_fields(@dm.indices('abstract_cats')).should.eq cat_indices
+  end
+
   should 'reflect type' do
     model, local_dm = create_fake_model
     model.storage_names[:default] = 'abstract_comments'

data/lib/dm-is-reflective/version.rb

@@ -1,4 +1,4 @@
 
 module DmIsReflective
-  VERSION = '1.3.0'
+  VERSION = '1.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dm-is-reflective
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Lin Jen-Shin (godfat)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2013-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dm-core