activerecord-sqlserver-adapter-schemas 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,48 @@
+
+== Schema support for Rails SQL Server 2000, 2005 and 2008 Adapter
+
+Adds support for schemas to the activerecord-sqlserver-adapter gem
+
+== Installation
+
+  $ gem install activerecord-sqlserver-adapter
+  $ gem install activerecord-sqlserver-adapter-schemas
+
+Optionally configure your gem dependencies in your rails environment.rb file.
+
+  config.gem 'activerecord-sqlserver-adapter', :version => 'x.x.xx'
+  config.gem 'activerecord-sqlserver-adapter-schemas', :version => 'x.x.xx'
+  
+== Using Schemas with ActiveRecord
+
+The simplest way to use schemas is to simply specify it as part of the table name
+
+  class FooBar < ActiveRecord::Base
+    set_table_name 'foo.bars'
+  end
+  
+To use any the following methods, you must first enable schema names:
+
+  ActiveRecord::Base.use_schema_names = true
+
+With use_schema_names enabled, models in a module will use the module name as the schema name automatically.  For example:
+
+  # the table name for this model would be assumed to be foo.bars
+  class Foo::Bar < ActiveRecord::Base
+  end
+  
+The schema name can also be set explicitly when use_schema_names is enabled:
+
+  class Bar < ActiveRecord::Base
+    set_schema_name 'foo'
+  end
+  
+== Migrations
+
+It is possible to have separate schema_migrations tables in different schemas existing in the database at the same time.  This is useful if you have multiple rails applications using the same database but different schemas.
+
+To use this feature, use different users for each application with different default schemas set in the database.  So if you have 2 rails applications, if they log in as different users with different default schemas, they each get their own schema_migrations table in that schema.
+
+== License
+
+Copyright 2010. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/lib/active_record/schemas/base.rb

@@ -0,0 +1,57 @@
+# This module is used to make it easier to deal with legacy char fields by trimming them automatically after a find.
+module ActiveRecord
+module Schemas
+module Base
+  # returns true if schema names should be used.  Default is false
+  def use_schema_names?
+    read_inheritable_attribute(:use_schema_names)
+  end
+  
+  # sets if schema names should be used.
+  def use_schema_names=(value)
+    write_inheritable_attribute(:use_schema_names, value)
+  end
+  alias_method :set_use_schema_names, :use_schema_names=
+  
+  # returns the schema name, either based on the module (via reset_schema_name) of an explicitly set value defined by the class
+  def schema_name
+    reset_schema_name
+  end
+  
+  # calculates the schema name based on the class's module
+  def reset_schema_name
+    ar_descendant = class_of_active_record_descendant(self)
+    if ar_descendant == self
+      name = self.name.split('::').first.downcase
+      set_schema_name name
+      name
+    else
+      ar_descendant.schema_name
+    end
+  end
+  
+  # overrides the default schema based on the module
+  def schema_name=(value = nil, &block)
+    define_attr_method :schema_name, value, &block
+  end
+  alias_method :set_schema_name, :schema_name=
+  
+  # sets the table name with the schema
+  def reset_table_name_with_schema
+    ar_descendant = class_of_active_record_descendant(self)
+    if self == ar_descendant
+      name = reset_table_name
+      if use_schema_names? && schema_name
+        name = "#{"#{schema_name}." if schema_name}#{name}"
+        set_table_name name
+      end
+      name
+    else
+      name = ar_descendant.table_name
+      set_table_name name
+      name
+    end
+  end
+end
+end
+end

data/lib/active_record/schemas/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+module Schemas
+module ConnectionAdapters
+  
+module SqlserverAdapter
+  
+  # When this module is included, the following methods are chained in order
+  # to strip off the schema names if the schema is the default schema
+  def self.included(base)
+    base.alias_method_chain :columns, :default_schema_check
+    base.alias_method_chain :table_exists?, :default_schema_check
+    base.alias_method_chain :table_name_or_views_table_name, :default_schema_check
+  end
+  
+  def default_schema
+    unless sqlserver_2000?
+      @default_schema ||= select_values("SELECT default_schema_name FROM sys.database_principals WHERE type = 'S' and name = '#{self.quote_string(@connection_options[:username])}'").first
+    end
+    @default_schema ||= 'dbo'
+  end
+  attr_writer :default_schema
+  
+  def table_name_or_views_table_name_with_default_schema_check(table_name)
+    table_name = unqualify_table_name_if_default_schema(table_name)
+    table_name_or_views_table_name_without_default_schema_check(table_name)
+  end
+  
+  def table_exists_with_default_schema_check?(table_name)
+    table_name = unqualify_table_name_if_default_schema(table_name)
+    table_exists_without_default_schema_check?(table_name)
+  end
+  
+  def columns_with_default_schema_check(table_name, column_name = nil)
+    table_name = unqualify_table_name_if_default_schema(table_name) if table_name
+    columns_without_default_schema_check(table_name, column_name)
+  end
+  
+  def unqualify_schema_name(table_name)
+    parts = table_name.to_s.split('.')
+    parts.length == 1 ? default_schema : parts[parts.length - 2].gsub(/[\[\]]/,'')
+  end
+  
+  def unqualify_table_name_if_default_schema(table_name)
+    schema = unqualify_schema_name(table_name)
+    schema == default_schema ? unqualify_table_name(table_name) : table_name
+  end
+  
+  # override index name so that if there is a schema, rename it schema_table instead of schema.table
+  def index_name(table_name, options) #:nodoc:
+    super table_name.tr('.', '_'), options
+  end
+end
+
+end
+end
+end

data/lib/activerecord-sqlserver-adapter-schemas.rb

@@ -0,0 +1,151 @@
+require File.join(File.dirname(__FILE__), 'active_record', 'schemas', 'base')
+require File.join(File.dirname(__FILE__), 'active_record', 'schemas', 'connection_adapters', 'sqlserver_adapter')
+
+class ActiveRecord::Base
+  extend ActiveRecord::Schemas::Base
+  
+  def self.table_name
+    reset_table_name_with_schema
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::SQLServerAdapter
+  include ActiveRecord::Schemas::ConnectionAdapters::SqlserverAdapter
+  
+  # This method is overridden to support linked servers
+  def unqualify_db_name(table_name)
+    table_names = table_name.to_s.split('.')
+    table_names.length >= 3 ? table_names[0...table_names.length - 2].join('.').tr('[]','') : nil
+  end
+  
+  # This method is overridden to support schema names
+  def tables(name = nil)
+    # return schema.table unless the schema is the default schema, in which case just return table
+    info_schema_query do
+      select_values("SELECT TABLE_SCHEMA + '.' + TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME <> 'dtproperties'").collect do |table|
+        default_schema && table.index("#{default_schema}.") == 0 ? table[default_schema.length + 1..table.length] : table
+      end
+    end
+  end
+  
+  # This method is overridden to support schema names
+  def views(name = nil)
+    # return schema.view unless the schema is the default schema, in which case just return view
+    @sqlserver_views_cache ||= 
+      info_schema_query do
+         select_values("SELECT TABLE_SCHEMA + '.' + TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME NOT IN ('sysconstraints','syssegments')").collect do |view|
+           default_schema && view.index("#{default_schema}.") == 0 ? view[default_schema.length + 1..view.length] : view
+         end
+      end
+  end
+  
+  # This method is overridden to support references such as database..table
+  def quote_column_name(column_name)
+    column_name.to_s.split('..').collect do |part|
+      part.split('.').map{ |name| name =~ /^\[.*\]$/ ? name : "[#{name}]" }.join('.')
+    end.join('..')
+  end
+  
+  # overridden to support schemas.  sp_helpindex does not support linked servers
+  def indexes(table_name, name = nil)
+    db_name = unqualify_db_name(table_name)
+    db_name << '.' if db_name
+    schema_name = unqualify_schema_name(table_name) << '.'
+    table_name = unqualify_table_name(table_name)
+
+    select("EXEC sp_helpindex '#{quote_table_name("#{db_name}#{schema_name}#{table_name}")}'",name).inject([]) do |indexes,index|
+      if index['index_description'] =~ /primary key/
+        indexes
+      else
+        name    = index['index_name']
+        unique  = index['index_description'] =~ /unique/
+        columns = index['index_keys'].split(',').map do |column|
+          column.strip!
+          column.gsub! '(-)', '' if column.ends_with?('(-)')
+          column
+        end
+        indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, columns)
+      end
+    end
+  end
+  
+  def view_information(table_name)
+    db_name = unqualify_db_name(table_name)
+    schema_name = unqualify_schema_name(table_name)
+    table_name = unqualify_table_name(table_name)
+    
+    @@sqlserver_view_information_cache ||= {}
+    @@sqlserver_view_information_cache[table_name.downcase] ||= begin
+      sql = "SELECT * FROM #{"#{db_name}." if db_name}INFORMATION_SCHEMA.VIEWS WHERE TABLE_NAME = '#{table_name}'"
+      sql << " and TABLE_SCHEMA = '#{schema_name}'" if schema_name
+      view_info = info_schema_query { select_one(sql) }
+      if view_info
+        if view_info['VIEW_DEFINITION'].blank? || view_info['VIEW_DEFINITION'].length == 4000
+          view_info['VIEW_DEFINITION'] = info_schema_query { select_values("EXEC sp_helptext #{table_name}").join }
+        end
+      end
+      view_info
+    end
+  end
+  
+  def column_definitions(table_name)
+    db_name = unqualify_db_name(table_name)
+    db_name << '.' if db_name
+    schema_name = unqualify_schema_name(table_name)
+    table_name = unqualify_table_name(table_name)
+    sql = %{
+      SELECT
+      columns.TABLE_NAME as table_name,
+      columns.COLUMN_NAME as name,
+      columns.DATA_TYPE as type,
+      columns.COLUMN_DEFAULT as default_value,
+      columns.NUMERIC_SCALE as numeric_scale,
+      columns.NUMERIC_PRECISION as numeric_precision,
+      CASE
+        WHEN columns.DATA_TYPE IN ('nchar','nvarchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
+        ELSE COL_LENGTH(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME, columns.COLUMN_NAME)
+      END as length,
+      CASE
+        WHEN columns.IS_NULLABLE = 'YES' THEN 1
+        ELSE NULL
+      end as is_nullable,
+      CASE
+        WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 0 THEN NULL
+        ELSE 1
+      END as is_identity
+      FROM #{db_name}INFORMATION_SCHEMA.COLUMNS columns
+      WHERE columns.TABLE_NAME = '#{table_name}'
+      #{"AND columns.TABLE_SCHEMA = '#{schema_name}'" if schema_name}
+      ORDER BY columns.ordinal_position
+    }.gsub(/[ \t\r\n]+/,' ')
+    results = info_schema_query { select(sql,nil,true) }
+    results.collect do |ci|
+      ci.symbolize_keys!
+      ci[:type] = case ci[:type]
+                  when /^bit|image|text|ntext|datetime$/
+                    ci[:type]
+                  when /^numeric|decimal$/i
+                    "#{ci[:type]}(#{ci[:numeric_precision]},#{ci[:numeric_scale]})"
+                  when /^char|nchar|varchar|nvarchar|varbinary|bigint|int|smallint$/
+                    ci[:length].to_i == -1 ? "#{ci[:type]}(max)" : "#{ci[:type]}(#{ci[:length]})"
+                  else
+                    ci[:type]
+                  end
+      if ci[:default_value].nil? && views.include?(table_name)
+        real_table_name = table_name_or_views_table_name(table_name)
+        real_column_name = views_real_column_name(table_name,ci[:name])
+        col_default_sql = "SELECT c.COLUMN_DEFAULT FROM #{db_name}INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
+        ci[:default_value] = info_schema_query { select_value(col_default_sql) }
+      end
+      ci[:default_value] = case ci[:default_value]
+                           when nil, '(null)', '(NULL)'
+                             nil
+                           else
+                             match_data = ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/m)
+                             match_data ? match_data[1] : nil
+                           end
+      ci[:null] = ci[:is_nullable].to_i == 1 ; ci.delete(:is_nullable)
+      ci
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: activerecord-sqlserver-adapter-schemas
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Airlite Plastics
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord-sqlserver-adapter
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Adds schema support to activerecord-sqlserver-adapter.
+email: dtjablonski@airliteplastics.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- lib/activerecord-sqlserver-adapter-schemas.rb
+- lib/active_record/schemas/base.rb
+- lib/active_record/schemas/connection_adapters/sqlserver_adapter.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Adds schema support to activerecord-sqlserver-adapter.
+test_files: []
+