Module: Sequel::ADO::Access::DatabaseMethods

Includes:
Sequel::Access::DatabaseMethods, Database::SplitAlterTable
Defined in:
lib/sequel/adapters/ado/access.rb

Instance Method Summary collapse

Methods included from Sequel::Access::DatabaseMethods

#database_type, #rename_table, #serial_primary_key_options

Instance Method Details

#alter_table(name) ⇒ Object

Remove cached schema after altering a table, since otherwise it can be cached incorrectly in the rename column case.



95
96
97
98
99
 
# File 'lib/sequel/adapters/ado/access.rb', line 95

def alter_table(name, *)
  super
  remove_cached_schema(name)
  nil
end

#disconnect_connection(conn) ⇒ Object

Access doesn’t let you disconnect if inside a transaction, so try rolling back an existing transaction first.



103
104
105
106
 
# File 'lib/sequel/adapters/ado/access.rb', line 103

def disconnect_connection(conn)
  conn.RollbackTrans rescue nil
  super
end

#execute_insert(sql, opts = OPTS) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/sequel/adapters/ado/access.rb', line 108

def execute_insert(sql, opts=OPTS)
  synchronize(opts[:server]) do |conn|
    begin
      log_connection_yield(sql, conn){conn.Execute(sql)}
      last_insert_sql = "SELECT @@IDENTITY"
      res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)}
      res.GetRows.transpose.each{|r| return r.shift}
    rescue ::WIN32OLERuntimeError => e
      raise_error(e)
    end
  end
  nil
end

#foreign_key_list(table, opts = OPTS) ⇒ Object

OpenSchema returns compound foreign key relationships as multiple rows



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/sequel/adapters/ado/access.rb', line 148

def foreign_key_list(table, opts=OPTS)
  m = output_identifier_meth
  fks = ado_schema_foreign_keys(table).inject({}) do |memo, fk|
    name = m.call(fk['FK_NAME'])
    specs = memo[name] ||= {
      :columns => [],
      :table   => m.call(fk['PK_TABLE_NAME']),
      :key     => [],
      :deferrable => fk['DEFERRABILITY'],
      :name    => name,
      :on_delete => fk['DELETE_RULE'],
      :on_update => fk['UPDATE_RULE']
    }
    specs[:columns] << m.call(fk['FK_COLUMN_NAME'])
    specs[:key]     << m.call(fk['PK_COLUMN_NAME'])
    memo
  end
  fks.values
end

#indexes(table_name, opts = OPTS) ⇒ Object

OpenSchema returns compound indexes as multiple rows



133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/sequel/adapters/ado/access.rb', line 133

def indexes(table_name,opts=OPTS)
  m = output_identifier_meth
  idxs = ado_schema_indexes(table_name).inject({}) do |memo, idx|
    unless idx["PRIMARY_KEY"]
      index = memo[m.call(idx["INDEX_NAME"])] ||= {
        :columns=>[], :unique=>idx["UNIQUE"]
      }
      index[:columns] << m.call(idx["COLUMN_NAME"])
    end
    memo
  end
  idxs
end

#tables(opts = OPTS) ⇒ Object 



122
123
124
125
 
# File 'lib/sequel/adapters/ado/access.rb', line 122

def tables(opts=OPTS)
  m = output_identifier_meth
  ado_schema_tables.map {|tbl| m.call(tbl['TABLE_NAME'])}
end

#views(opts = OPTS) ⇒ Object 



127
128
129
130
 
# File 'lib/sequel/adapters/ado/access.rb', line 127

def views(opts=OPTS)
  m = output_identifier_meth
  ado_schema_views.map {|tbl| m.call(tbl['TABLE_NAME'])}
end