Module: ActiveRecord::ConnectionAdapters::Sunstone::SchemaStatements

Included in:
ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter
Defined in:
lib/active_record/connection_adapters/sunstone/schema_statements.rb

Instance Method Summary collapse

Instance Method Details

#column_definitions(table_name) ⇒ Object

Returns the list of a table’s column names, data types, and default values.

Query implementation notes:

- format_type includes the column size constraint, e.g. varchar(50)
- ::regclass is a function that gives the id for a table name



41
42
43
44
45
46
47
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 41

def column_definitions(table_name) # :nodoc:
  puts table_name.inspect
  puts definition(table_name).inspect
  # TODO: settle on schema, I think we've switched to attributes, so
  # columns can be removed soon?
  definition(table_name)['attributes'] || definition(table_name)['columns']
end

#column_name_for_operation(operation, node) ⇒ Object

:nodoc:



84
85
86
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 84

def column_name_for_operation(operation, node) # :nodoc:
  visitor.accept(node, collector).first[operation.to_sym]
end

#columns(table_name) ⇒ Object

Returns the list of all column definitions for a table.



15
16
17
18
19
20
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 15

def columns(table_name)
  # Limit, precision, and scale are all handled by the superclass.
  column_definitions(table_name).map do |column_name, options|
    new_column(column_name, options)
  end
end

#columns_for_distinct(columns, orders) ⇒ Object

Given a set of columns and an ORDER BY clause, returns the columns for a SELECT DISTINCT. PostgreSQL, MySQL, and Oracle override this for custom DISTINCT syntax - they require the order columns appear in the SELECT.

columns_for_distinct("posts.id", ["posts.created_at desc"])



94
95
96
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 94

def columns_for_distinct(columns, orders) # :nodoc:
  columns
end

#definition(table_name) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 22

def definition(table_name)
  # TODO move @definitions to using @schema_cache
  @definitions = {} if !defined?(@definitions)

  if @definitions[table_name]
    return @definitions[table_name]
  end

  response = with_raw_connection { |conn| conn.get("/#{table_name}/schema") }
  @definitions[table_name] = JSON.parse(response.body)
rescue ::Sunstone::Exception::NotFound
  raise ActiveRecord::StatementInvalid, "Table \"#{table_name}\" does not exist"
end

#distinct_relation_for_primary_key(relation) ⇒ Object

:nodoc:



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 98

def distinct_relation_for_primary_key(relation) # :nodoc:
  values = columns_for_distinct(
    relation.table[relation.primary_key],
    relation.order_values
  )

  limited = relation.reselect(values).distinct!
  limited_ids = select_rows(limited.arel, "SQL").map(&:last)

  if limited_ids.empty?
    relation.none!
  else
    relation.where!(relation.primary_key => limited_ids)
  end

  relation.limit_value = relation.offset_value = nil
  relation
end

#fetch_type_metadata(options) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 72

def fetch_type_metadata(options)
  cast_type = lookup_cast_type(options)
  simple_type = SqlTypeMetadata.new(
    sql_type: options['type'],
    type: cast_type.type,
    limit: cast_type.limit,
    precision: cast_type.precision,
    scale: cast_type.scale
  )
  SunstoneSQLTypeMetadata.new(simple_type, options)
end

#limit_definition(table_name) ⇒ Object

Returns the limit definition of the table (the maximum limit that can be used).



51
52
53
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 51

def limit_definition(table_name)
  definition(table_name)['limit'] || nil
end

#lookup_cast_type(options) ⇒ Object 



68
69
70
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 68

def lookup_cast_type(options)
  @type_map.lookup(options['type'], options.symbolize_keys)
end

#new_column(name, options) ⇒ Object 



63
64
65
66
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 63

def new_column(name, options)
  sql_type_metadata = fetch_type_metadata(options)
  SunstoneColumn.new(name, sql_type_metadata, options)
end

#primary_key(table) ⇒ Object

Returns just a table’s primary key



120
121
122
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 120

def primary_key(table)
  columns(table).find{ |c| c.primary_key? }.try(:name)
end

#table_exists?(name) ⇒ Boolean

Returns true if table exists. If the schema is not specified as part of name then it will only find tables within the current schema search path (regardless of permissions to access tables in other schemas)

Returns:

  • (Boolean) 


10
11
12
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 10

def table_exists?(name)
  tables.include?(name)
end

#tables ⇒ Object 



55
56
57
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 55

def tables
  JSON.parse(with_raw_connection { |conn| conn.get('/tables').body })
end

#views ⇒ Object 



59
60
61
 
# File 'lib/active_record/connection_adapters/sunstone/schema_statements.rb', line 59

def views
  []
end