module Sequel::ADO::Access::DatabaseMethods
Public Instance Methods
Source
# File lib/sequel/adapters/ado/access.rb 95 def alter_table(name, *) 96 super 97 remove_cached_schema(name) 98 nil 99 end
Remove cached schema after altering a table, since otherwise it can be cached incorrectly in the rename column case.
Calls superclass method
Source
# File lib/sequel/adapters/ado/access.rb 103 def disconnect_connection(conn) 104 conn.RollbackTrans rescue nil 105 super 106 end
Access
doesn’t let you disconnect if inside a transaction, so try rolling back an existing transaction first.
Calls superclass method
Source
# File lib/sequel/adapters/ado/access.rb 108 def execute_insert(sql, opts=OPTS) 109 synchronize(opts[:server]) do |conn| 110 begin 111 log_connection_yield(sql, conn){conn.Execute(sql)} 112 last_insert_sql = "SELECT @@IDENTITY" 113 res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)} 114 res.GetRows.transpose.each{|r| return r.shift} 115 rescue ::WIN32OLERuntimeError => e 116 raise_error(e) 117 end 118 end 119 nil 120 end
Source
# File lib/sequel/adapters/ado/access.rb 148 def foreign_key_list(table, opts=OPTS) 149 m = output_identifier_meth 150 fks = ado_schema_foreign_keys(table).inject({}) do |memo, fk| 151 name = m.call(fk['FK_NAME']) 152 specs = memo[name] ||= { 153 :columns => [], 154 :table => m.call(fk['PK_TABLE_NAME']), 155 :key => [], 156 :deferrable => fk['DEFERRABILITY'], 157 :name => name, 158 :on_delete => fk['DELETE_RULE'], 159 :on_update => fk['UPDATE_RULE'] 160 } 161 specs[:columns] << m.call(fk['FK_COLUMN_NAME']) 162 specs[:key] << m.call(fk['PK_COLUMN_NAME']) 163 memo 164 end 165 fks.values 166 end
OpenSchema returns compound foreign key relationships as multiple rows
Source
# File lib/sequel/adapters/ado/access.rb 133 def indexes(table_name,opts=OPTS) 134 m = output_identifier_meth 135 idxs = ado_schema_indexes(table_name).inject({}) do |memo, idx| 136 unless idx["PRIMARY_KEY"] 137 index = memo[m.call(idx["INDEX_NAME"])] ||= { 138 :columns=>[], :unique=>idx["UNIQUE"] 139 } 140 index[:columns] << m.call(idx["COLUMN_NAME"]) 141 end 142 memo 143 end 144 idxs 145 end
OpenSchema returns compound indexes as multiple rows
Source
# File lib/sequel/adapters/ado/access.rb 122 def tables(opts=OPTS) 123 m = output_identifier_meth 124 ado_schema_tables.map {|tbl| m.call(tbl['TABLE_NAME'])} 125 end
Source
# File lib/sequel/adapters/ado/access.rb 127 def views(opts=OPTS) 128 m = output_identifier_meth 129 ado_schema_views.map {|tbl| m.call(tbl['TABLE_NAME'])} 130 end
Private Instance Methods
Source
# File lib/sequel/adapters/ado/access.rb 279 def ado_schema_columns(table_name) 280 rows=[] 281 fetch_ado_schema(:columns, [nil,nil,table_name.to_s,nil]) do |row| 282 rows << AdoSchema::Column.new(row) 283 end 284 rows.sort!{|a,b| a["ORDINAL_POSITION"] <=> b["ORDINAL_POSITION"]} 285 end
Source
# File lib/sequel/adapters/ado/access.rb 287 def ado_schema_foreign_keys(table_name) 288 rows=[] 289 fetch_ado_schema(:foreign_keys, [nil,nil,nil,nil,nil,table_name.to_s]) do |row| 290 rows << row 291 end 292 rows.sort!{|a,b| a["ORDINAL"] <=> b["ORDINAL"]} 293 end
Source
# File lib/sequel/adapters/ado/access.rb 271 def ado_schema_indexes(table_name) 272 rows=[] 273 fetch_ado_schema(:indexes, [nil,nil,nil,nil,table_name.to_s]) do |row| 274 rows << row 275 end 276 rows 277 end
Source
# File lib/sequel/adapters/ado/access.rb 255 def ado_schema_tables 256 rows=[] 257 fetch_ado_schema(:tables, [nil,nil,nil,'TABLE']) do |row| 258 rows << row 259 end 260 rows 261 end
Source
# File lib/sequel/adapters/ado/access.rb 263 def ado_schema_views 264 rows=[] 265 fetch_ado_schema(:views, [nil,nil,nil]) do |row| 266 rows << row 267 end 268 rows 269 end
Source
# File lib/sequel/adapters/ado/access.rb 172 def alter_table_sql(table, op) 173 case op[:op] 174 when :rename_column 175 unless sch = op[:schema] 176 raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]} 177 sch = sch.last 178 end 179 [ 180 alter_table_sql(table, :op=>:add_column, :name=>op[:new_name], :default=>sch[:ruby_default], :type=>sch[:db_type], :null=>sch[:allow_null]), 181 from(table).update_sql(op[:new_name]=>op[:name]), 182 alter_table_sql(table, :op=>:drop_column, :name=>op[:name]) 183 ] 184 when :set_column_null, :set_column_default 185 raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]} 186 sch = sch.last 187 188 sch = if op[:op] == :set_column_null 189 sch.merge(:allow_null=>op[:null]) 190 else 191 sch.merge(:ruby_default=>op[:default]) 192 end 193 194 [ 195 alter_table_sql(table, :op=>:rename_column, :name=>op[:name], :new_name=>:sequel_access_backup_column, :schema=>sch), 196 alter_table_sql(table, :op=>:rename_column, :new_name=>op[:name], :name=>:sequel_access_backup_column, :schema=>sch) 197 ] 198 else 199 super 200 end 201 end
Emulate rename_column by adding the column, copying data from the old column, and dropping the old column.
Calls superclass method
Source
# File lib/sequel/adapters/ado/access.rb 203 def begin_transaction(conn, opts=OPTS) 204 log_connection_yield('Transaction.begin', conn){conn.BeginTrans} 205 end
Source
# File lib/sequel/adapters/ado/access.rb 207 def commit_transaction(conn, opts=OPTS) 208 log_connection_yield('Transaction.commit', conn){conn.CommitTrans} 209 end
Source
# File lib/sequel/adapters/ado/access.rb 310 def execute_open_ado_schema(type, criteria=[]) 311 ado_schema = AdoSchema.new(type, criteria) 312 synchronize(opts[:server]) do |conn| 313 begin 314 r = log_connection_yield("OpenSchema #{type.inspect}, #{criteria.inspect}", conn) { 315 if ado_schema.criteria.empty? 316 conn.OpenSchema(ado_schema.type) 317 else 318 conn.OpenSchema(ado_schema.type, ado_schema.criteria) 319 end 320 } 321 yield(r) if defined?(yield) 322 rescue ::WIN32OLERuntimeError => e 323 raise_error(e) 324 end 325 end 326 nil 327 end
This is like execute() in that it yields an ADO
RecordSet, except instead of an SQL
interface there’s this OpenSchema call cf. msdn.microsoft.com/en-us/library/ee275721(v=bts.10)
Source
# File lib/sequel/adapters/ado/access.rb 295 def fetch_ado_schema(type, criteria=[]) 296 execute_open_ado_schema(type, criteria) do |s| 297 cols = [] 298 s.Fields.each{|f| cols << f.Name} 299 s.GetRows.transpose.each do |r| 300 row = {} 301 cols.each{|c| row[c] = r.shift} 302 yield row 303 end unless s.eof 304 end 305 end
Source
# File lib/sequel/adapters/ado/access.rb 211 def rollback_transaction(conn, opts=OPTS) 212 log_connection_yield('Transaction.rollback', conn){conn.RollbackTrans} 213 end
Source
# File lib/sequel/adapters/ado/access.rb 215 def schema_column_type(db_type) 216 case db_type.downcase 217 when 'bit' 218 :boolean 219 when 'byte', 'guid' 220 :integer 221 when 'image' 222 :blob 223 else 224 super 225 end 226 end
Calls superclass method
Source
# File lib/sequel/adapters/ado/access.rb 228 def schema_parse_table(table_name, opts) 229 m = output_identifier_meth(opts[:dataset]) 230 m2 = input_identifier_meth(opts[:dataset]) 231 tn = m2.call(table_name.to_s) 232 idxs = ado_schema_indexes(tn) 233 ado_schema_columns(tn).map {|row| 234 specs = { 235 :allow_null => row.allow_null, 236 :db_type => row.db_type, 237 :default => row.default, 238 :primary_key => !!idxs.find {|idx| 239 idx["COLUMN_NAME"] == row["COLUMN_NAME"] && 240 idx["PRIMARY_KEY"] 241 }, 242 :type => if row.db_type =~ /decimal/i && row.scale == 0 243 :integer 244 else 245 schema_column_type(row.db_type) 246 end, 247 :ado_type => row["DATA_TYPE"] 248 } 249 specs[:default] = nil if blank_object?(specs[:default]) 250 specs[:allow_null] = specs[:allow_null] && !specs[:primary_key] 251 [ m.call(row["COLUMN_NAME"]), specs ] 252 } 253 end