Module: Dynamoid::Persistence::ClassMethods

Defined in:
lib/dynamoid/persistence.rb

Instance Method Summary collapse

Instance Method Details

#create_table(options = {}) ⇒ Object

Creates a table.

Parameters:

  • options (Hash) (defaults to: {}) —

    options to pass for table creation

Options Hash (options):

  • :id (Symbol) —

    the id field for the table

  • :table_name (Symbol) —

    the actual name for the table

  • :read_capacity (Integer) —

    set the read capacity for the table; does not work on existing tables

  • :write_capacity (Integer) —

    set the write capacity for the table; does not work on existing tables

  • {range_key (Hash) —

    > :type} a hash of the name of the range key and a symbol of its type

Since:

  • 0.4.0



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/dynamoid/persistence.rb', line 30

def create_table(options = {})
  if self.range_key
    range_key_hash = { range_key => dynamo_type(attributes[range_key][:type]) }
  else
    range_key_hash = nil
  end
  options = {
    :id => self.hash_key,
    :table_name => self.table_name,
    :write_capacity => self.write_capacity,
    :read_capacity => self.read_capacity,
    :range_key => range_key_hash
  }.merge(options)

  return true if table_exists?(options[:table_name])

  Dynamoid::Adapter.tables << options[:table_name] if Dynamoid::Adapter.create_table(options[:table_name], options[:id], options)
end

#dynamo_type(type) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
 
# File 'lib/dynamoid/persistence.rb', line 124

def dynamo_type(type)
  case type
  when :integer, :float, :datetime
    :number
  when :string, :serialized
    :string
  else
    raise 'unknown type'
  end
end

#from_database(attrs = {}) ⇒ Object 



56
57
58
59
 
# File 'lib/dynamoid/persistence.rb', line 56

def from_database(attrs = {})
  clazz = attrs[:type] ? obj = attrs[:type].constantize : self
  clazz.new(attrs).tap { |r| r.new_record = false }
end

#table_exists?(table_name) ⇒ Boolean

Does a table with this name exist?

Returns:

  • (Boolean)

Since:

  • 0.2.0



52
53
54
 
# File 'lib/dynamoid/persistence.rb', line 52

def table_exists?(table_name)
  Dynamoid::Adapter.tables ? Dynamoid::Adapter.tables.include?(table_name) : false
end

#table_name ⇒ Object 



16
17
18
 
# File 'lib/dynamoid/persistence.rb', line 16

def table_name
  @table_name ||= "#{Dynamoid::Config.namespace}_#{options[:name] || base_class.name.split('::').last.downcase.pluralize}"
end

#undump(incoming = nil) ⇒ Object

Undump an object into a hash, converting each type from a string representation of itself into the type specified by the field.

Since:

  • 0.2.0



64
65
66
67
68
69
70
71
72
 
# File 'lib/dynamoid/persistence.rb', line 64

def undump(incoming = nil)
  incoming = (incoming || {}).symbolize_keys
  Hash.new.tap do |hash|
    self.attributes.each do |attribute, options|
      hash[attribute] = undump_field(incoming[attribute], options)
    end
    incoming.each {|attribute, value| hash[attribute] = value unless hash.has_key? attribute }
  end
end

#undump_field(value, options) ⇒ Object

Undump a value for a given type. Given a string, it’ll determine (based on the type provided) whether to turn it into a string, integer, float, set, array, datetime, or serialized return value.

Since:

  • 0.2.0



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/dynamoid/persistence.rb', line 78

def undump_field(value, options)
  if value.nil? && (default_value = options[:default])
    value = default_value.respond_to?(:call) ? default_value.call : default_value
  else
    return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
  end

  case options[:type]
  when :string
    value.to_s
  when :integer
    value.to_i
  when :float
    value.to_f
  when :set, :array
    if value.is_a?(Set) || value.is_a?(Array)
      value
    else
      Set[value]
    end
  when :datetime
    if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
      value
    else
      Time.at(value).to_datetime
    end
  when :serialized
    if value.is_a?(String)
      options[:serializer] ? options[:serializer].load(value) : YAML.load(value)
    else
      value
    end
  when :boolean
    # persisted as 't', but because undump is called during initialize it can come in as true
    if value == 't' || value == true
      true
    elsif value == 'f' || value == false
      false
    else
      raise ArgumentError, "Boolean column neither true nor false"
    end
  else
    raise ArgumentError, "Unknown type #{options[:type]}"
  end
end