dynamoid 3.8.0 → 3.10.0

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -2,6 +2,7 @@
 
 require_relative 'aws_sdk_v3/query'
 require_relative 'aws_sdk_v3/scan'
+require_relative 'aws_sdk_v3/execute_statement'
 require_relative 'aws_sdk_v3/create_table'
 require_relative 'aws_sdk_v3/batch_get_item'
 require_relative 'aws_sdk_v3/item_updater'
@@ -13,7 +14,7 @@ module Dynamoid
   module AdapterPlugin
     # The AwsSdkV3 adapter provides support for the aws-sdk version 2 for ruby.
 
-    # Note: Don't use keyword arguments in public methods as far as method
+    # NOTE: Don't use keyword arguments in public methods as far as method
     # calls on adapter are delegated to the plugin.
     #
     # There are breaking changes in Ruby related to delegating keyword
@@ -23,31 +24,6 @@ module Dynamoid
 
     class AwsSdkV3
       EQ = 'EQ'
-      RANGE_MAP = {
-        range_greater_than: 'GT',
-        range_less_than:    'LT',
-        range_gte:          'GE',
-        range_lte:          'LE',
-        range_begins_with:  'BEGINS_WITH',
-        range_between:      'BETWEEN',
-        range_eq:           'EQ'
-      }.freeze
-
-      FIELD_MAP = {
-        eq:           'EQ',
-        ne:           'NE',
-        gt:           'GT',
-        lt:           'LT',
-        gte:          'GE',
-        lte:          'LE',
-        begins_with:  'BEGINS_WITH',
-        between:      'BETWEEN',
-        in:           'IN',
-        contains:     'CONTAINS',
-        not_contains: 'NOT_CONTAINS',
-        null:         'NULL',
-        not_null:     'NOT_NULL',
-      }.freeze
       HASH_KEY  = 'HASH'
       RANGE_KEY = 'RANGE'
       STRING_TYPE  = 'S'
@@ -69,26 +45,72 @@ module Dynamoid
 
       CONNECTION_CONFIG_OPTIONS = %i[endpoint region http_continue_timeout http_idle_timeout http_open_timeout http_read_timeout].freeze
 
-      attr_reader :table_cache
+      # See https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
+      # rubocop:disable Metrics/CollectionLiteralLength
+      RESERVED_WORDS = Set.new(
+        %i[
+          ABORT ABSOLUTE ACTION ADD AFTER AGENT AGGREGATE ALL ALLOCATE ALTER ANALYZE
+          AND ANY ARCHIVE ARE ARRAY AS ASC ASCII ASENSITIVE ASSERTION ASYMMETRIC AT
+          ATOMIC ATTACH ATTRIBUTE AUTH AUTHORIZATION AUTHORIZE AUTO AVG BACK BACKUP
+          BASE BATCH BEFORE BEGIN BETWEEN BIGINT BINARY BIT BLOB BLOCK BOOLEAN BOTH
+          BREADTH BUCKET BULK BY BYTE CALL CALLED CALLING CAPACITY CASCADE CASCADED
+          CASE CAST CATALOG CHAR CHARACTER CHECK CLASS CLOB CLOSE CLUSTER CLUSTERED
+          CLUSTERING CLUSTERS COALESCE COLLATE COLLATION COLLECTION COLUMN COLUMNS
+          COMBINE COMMENT COMMIT COMPACT COMPILE COMPRESS CONDITION CONFLICT CONNECT
+          CONNECTION CONSISTENCY CONSISTENT CONSTRAINT CONSTRAINTS CONSTRUCTOR
+          CONSUMED CONTINUE CONVERT COPY CORRESPONDING COUNT COUNTER CREATE CROSS
+          CUBE CURRENT CURSOR CYCLE DATA DATABASE DATE DATETIME DAY DEALLOCATE DEC
+          DECIMAL DECLARE DEFAULT DEFERRABLE DEFERRED DEFINE DEFINED DEFINITION
+          DELETE DELIMITED DEPTH DEREF DESC DESCRIBE DESCRIPTOR DETACH DETERMINISTIC
+          DIAGNOSTICS DIRECTORIES DISABLE DISCONNECT DISTINCT DISTRIBUTE DO DOMAIN
+          DOUBLE DROP DUMP DURATION DYNAMIC EACH ELEMENT ELSE ELSEIF EMPTY ENABLE
+          END EQUAL EQUALS ERROR ESCAPE ESCAPED EVAL EVALUATE EXCEEDED EXCEPT
+          EXCEPTION EXCEPTIONS EXCLUSIVE EXEC EXECUTE EXISTS EXIT EXPLAIN EXPLODE
+          EXPORT EXPRESSION EXTENDED EXTERNAL EXTRACT FAIL FALSE FAMILY FETCH FIELDS
+          FILE FILTER FILTERING FINAL FINISH FIRST FIXED FLATTERN FLOAT FOR FORCE
+          FOREIGN FORMAT FORWARD FOUND FREE FROM FULL FUNCTION FUNCTIONS GENERAL
+          GENERATE GET GLOB GLOBAL GO GOTO GRANT GREATER GROUP GROUPING HANDLER HASH
+          HAVE HAVING HEAP HIDDEN HOLD HOUR IDENTIFIED IDENTITY IF IGNORE IMMEDIATE
+          IMPORT IN INCLUDING INCLUSIVE INCREMENT INCREMENTAL INDEX INDEXED INDEXES
+          INDICATOR INFINITE INITIALLY INLINE INNER INNTER INOUT INPUT INSENSITIVE
+          INSERT INSTEAD INT INTEGER INTERSECT INTERVAL INTO INVALIDATE IS ISOLATION
+          ITEM ITEMS ITERATE JOIN KEY KEYS LAG LANGUAGE LARGE LAST LATERAL LEAD
+          LEADING LEAVE LEFT LENGTH LESS LEVEL LIKE LIMIT LIMITED LINES LIST LOAD
+          LOCAL LOCALTIME LOCALTIMESTAMP LOCATION LOCATOR LOCK LOCKS LOG LOGED LONG
+          LOOP LOWER MAP MATCH MATERIALIZED MAX MAXLEN MEMBER MERGE METHOD METRICS
+          MIN MINUS MINUTE MISSING MOD MODE MODIFIES MODIFY MODULE MONTH MULTI
+          MULTISET NAME NAMES NATIONAL NATURAL NCHAR NCLOB NEW NEXT NO NONE NOT NULL
+          NULLIF NUMBER NUMERIC OBJECT OF OFFLINE OFFSET OLD ON ONLINE ONLY OPAQUE
+          OPEN OPERATOR OPTION OR ORDER ORDINALITY OTHER OTHERS OUT OUTER OUTPUT
+          OVER OVERLAPS OVERRIDE OWNER PAD PARALLEL PARAMETER PARAMETERS PARTIAL
+          PARTITION PARTITIONED PARTITIONS PATH PERCENT PERCENTILE PERMISSION
+          PERMISSIONS PIPE PIPELINED PLAN POOL POSITION PRECISION PREPARE PRESERVE
+          PRIMARY PRIOR PRIVATE PRIVILEGES PROCEDURE PROCESSED PROJECT PROJECTION
+          PROPERTY PROVISIONING PUBLIC PUT QUERY QUIT QUORUM RAISE RANDOM RANGE RANK
+          RAW READ READS REAL REBUILD RECORD RECURSIVE REDUCE REF REFERENCE
+          REFERENCES REFERENCING REGEXP REGION REINDEX RELATIVE RELEASE REMAINDER
+          RENAME REPEAT REPLACE REQUEST RESET RESIGNAL RESOURCE RESPONSE RESTORE
+          RESTRICT RESULT RETURN RETURNING RETURNS REVERSE REVOKE RIGHT ROLE ROLES
+          ROLLBACK ROLLUP ROUTINE ROW ROWS RULE RULES SAMPLE SATISFIES SAVE SAVEPOINT
+          SCAN SCHEMA SCOPE SCROLL SEARCH SECOND SECTION SEGMENT SEGMENTS SELECT SELF
+          SEMI SENSITIVE SEPARATE SEQUENCE SERIALIZABLE SESSION SET SETS SHARD SHARE
+          SHARED SHORT SHOW SIGNAL SIMILAR SIZE SKEWED SMALLINT SNAPSHOT SOME SOURCE
+          SPACE SPACES SPARSE SPECIFIC SPECIFICTYPE SPLIT SQL SQLCODE SQLERROR
+          SQLEXCEPTION SQLSTATE SQLWARNING START STATE STATIC STATUS STORAGE STORE
+          STORED STREAM STRING STRUCT STYLE SUB SUBMULTISET SUBPARTITION SUBSTRING
+          SUBTYPE SUM SUPER SYMMETRIC SYNONYM SYSTEM TABLE TABLESAMPLE TEMP TEMPORARY
+          TERMINATED TEXT THAN THEN THROUGHPUT TIME TIMESTAMP TIMEZONE TINYINT TO
+          TOKEN TOTAL TOUCH TRAILING TRANSACTION TRANSFORM TRANSLATE TRANSLATION
+          TREAT TRIGGER TRIM TRUE TRUNCATE TTL TUPLE TYPE UNDER UNDO UNION UNIQUE UNIT
+          UNKNOWN UNLOGGED UNNEST UNPROCESSED UNSIGNED UNTIL UPDATE UPPER URL USAGE
+          USE USER USERS USING UUID VACUUM VALUE VALUED VALUES VARCHAR VARIABLE
+          VARIANCE VARINT VARYING VIEW VIEWS VIRTUAL VOID WAIT WHEN WHENEVER WHERE
+          WHILE WINDOW WITH WITHIN WITHOUT WORK WRAPPED WRITE YEAR ZONE
+        ]
+      ).freeze
+      # rubocop:enable Metrics/CollectionLiteralLength
 
-      # Build an array of values for Condition
-      # Is used in ScanFilter and QueryFilter
-      # https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html
-      # @param [String] operator value of RANGE_MAP or FIELD_MAP hash, e.g. "EQ", "LT" etc
-      # @param [Object] value scalar value or array/set
-      def self.attribute_value_list(operator, value)
-        # For BETWEEN and IN operators we should keep value as is (it should be already an array)
-        # NULL and NOT_NULL require absence of attribute list
-        # For all the other operators we wrap the value with array
-        # https://docs.aws.amazon.com/en_us/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Conditions.html
-        if %w[BETWEEN IN].include?(operator)
-          [value].flatten
-        elsif %w[NULL NOT_NULL].include?(operator)
-          nil
-        else
-          [value]
-        end
-      end
+      attr_reader :table_cache
 
       # Establish the connection to DynamoDB.
       #
@@ -393,7 +415,7 @@ module Dynamoid
         item = client.get_item(table_name: table_name,
                                key: key_stanza(table, key, range_key),
                                consistent_read: consistent_read)[:item]
-        item ? result_item_to_hash(item) : nil
+        item ? item_to_hash(item) : nil
       end
 
       # Edits an existing item's attributes, or adds a new item to the table if it does not already exist. You can put, delete, or add attribute values
@@ -422,7 +444,7 @@ module Dynamoid
                                     attribute_updates: item_updater.attribute_updates,
                                     expected: expected_stanza(conditions),
                                     return_values: 'ALL_NEW')
-        result_item_to_hash(result[:attributes])
+        item_to_hash(result[:attributes])
       rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException => e
         raise Dynamoid::Errors::ConditionalCheckFailedException, e
       end
@@ -469,38 +491,45 @@ module Dynamoid
       # only really useful for range queries, since it can only find by one hash key at once. Only provide
       # one range key to the hash.
       #
+      #   Dynamoid.adapter.query('users', { id: [[:eq, '1']], age: [[:between, [10, 30]]] }, { batch_size: 1000 })
+      #
       # @param [String] table_name the name of the table
-      # @param [Hash] options the options to query the table with
-      # @option options [String] :hash_value the value of the hash key to find
-      # @option options [Number, Number] :range_between find the range key within this range
-      # @option options [Number] :range_greater_than find range keys greater than this
-      # @option options [Number] :range_less_than find range keys less than this
-      # @option options [Number] :range_gte find range keys greater than or equal to this
-      # @option options [Number] :range_lte find range keys less than or equal to this
+      # @param [Array[Array]] key_conditions conditions for the primary key attributes
+      # @param [Array[Array]] non_key_conditions (optional) conditions for non-primary key attributes
+      # @param [Hash] options (optional) the options to query the table with
+      # @option options [Boolean] :consistent_read You can set the ConsistentRead parameter to true and obtain a strongly consistent result
+      # @option options [Boolean] :scan_index_forward Specifies the order for index traversal: If true (default), the traversal is performed in ascending order; if false, the traversal is performed in descending order.
+      # @option options [Symbop] :select The attributes to be returned in the result (one of ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, ...)
+      # @option options [Symbol] :index_name The name of an index to query. This index can be any local secondary index or global secondary index on the table.
+      # @option options [Hash] :exclusive_start_key The primary key of the first item that this operation will evaluate.
+      # @option options [Integer] :batch_size The number of items to lazily load one by one
+      # @option options [Integer] :record_limit The maximum number of items to return (not necessarily the number of evaluated items)
+      # @option options [Integer] :scan_limit The maximum number of items to evaluate (not necessarily the number of matching items)
+      # @option options [Array[Symbol]] :project The attributes to retrieve from the table
       #
       # @return [Enumerable] matching items
       #
       # @since 1.0.0
       #
       # @todo Provide support for various other options http://docs.aws.amazon.com/sdkforruby/api/Aws/DynamoDB/Client.html#query-instance_method
-      def query(table_name, options = {})
+      def query(table_name, key_conditions, non_key_conditions = {}, options = {})
         Enumerator.new do |yielder|
           table = describe_table(table_name)
 
-          Query.new(client, table, options).call.each do |page|
+          Query.new(client, table, key_conditions, non_key_conditions, options).call.each do |page|
             yielder.yield(
-              page.items.map { |row| result_item_to_hash(row) },
+              page.items.map { |item| item_to_hash(item) },
               last_evaluated_key: page.last_evaluated_key
             )
           end
         end
       end
 
-      def query_count(table_name, options = {})
+      def query_count(table_name, key_conditions, non_key_conditions, options)
         table = describe_table(table_name)
         options[:select] = 'COUNT'
 
-        Query.new(client, table, options).call
+        Query.new(client, table, key_conditions, non_key_conditions, options).call
           .map(&:count)
           .reduce(:+)
       end
@@ -522,7 +551,7 @@ module Dynamoid
 
           Scan.new(client, table, conditions, options).call.each do |page|
             yielder.yield(
-              page.items.map { |row| result_item_to_hash(row) },
+              page.items.map { |item| item_to_hash(item) },
               last_evaluated_key: page.last_evaluated_key
             )
           end
@@ -557,7 +586,29 @@ module Dynamoid
       end
 
       def count(table_name)
-        describe_table(table_name, true).item_count
+        describe_table(table_name, reload: true).item_count
+      end
+
+      # Run PartiQL query.
+      #
+      #   Dynamoid.adapter.execute("SELECT * FROM users WHERE id = ?", ["758"])
+      #
+      # @param [String] statement PartiQL statement
+      # @param [Array] parameters a list of bind parameters
+      # @param [Hash] options
+      # @option [Boolean] consistent_read
+      # @return [[] | Array[Hash] | Enumerator::Lazy[Hash]] items when used a SELECT statement and empty Array otherwise
+      #
+      def execute(statement, parameters = [], options = {})
+        items = ExecuteStatement.new(client, statement, parameters, options).call
+
+        if items.is_a?(Array)
+          items
+        else
+          items.lazy.flat_map { |array| array }
+        end
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+        []
       end
 
       protected
@@ -582,10 +633,7 @@ module Dynamoid
         conditions.delete(:unless_exists).try(:each) do |col|
           expected[col.to_s][:exists] = false
         end
-        conditions.delete(:if_exists).try(:each) do |col, val|
-          expected[col.to_s][:exists] = true
-          expected[col.to_s][:value] = val
-        end
+
         conditions.delete(:if).try(:each) do |col, val|
           expected[col.to_s][:value] = val
         end
@@ -596,7 +644,7 @@ module Dynamoid
       #
       # New, semi-arbitrary API to get data on the table
       #
-      def describe_table(table_name, reload = false)
+      def describe_table(table_name, reload: false)
         (!reload && table_cache[table_name]) || begin
           table_cache[table_name] = Table.new(client.describe_table(table_name: table_name).data)
         end
@@ -605,10 +653,8 @@ module Dynamoid
       #
       # Converts a hash returned by get_item, scan, etc. into a key-value hash
       #
-      def result_item_to_hash(item)
-        {}.tap do |r|
-          item.each { |k, v| r[k.to_sym] = v }
-        end
+      def item_to_hash(hash)
+        hash.symbolize_keys
       end
 
       def sanitize_item(attributes)

data/lib/dynamoid/associations/belongs_to.rb

@@ -39,14 +39,14 @@ module Dynamoid
       #
       # @since 0.2.0
       def target_association
-        has_many_key_name = options[:inverse_of] || source.class.to_s.underscore.pluralize.to_sym
-        has_one_key_name = options[:inverse_of] || source.class.to_s.underscore.to_sym
-        unless target_class.associations[has_many_key_name].nil?
-          return has_many_key_name if target_class.associations[has_many_key_name][:type] == :has_many
+        name = options[:inverse_of] || source.class.to_s.underscore.pluralize.to_sym
+        if target_class.associations.dig(name, :type) == :has_many
+          return name
         end
 
-        unless target_class.associations[has_one_key_name].nil?
-          return has_one_key_name if target_class.associations[has_one_key_name][:type] == :has_one
+        name = options[:inverse_of] || source.class.to_s.underscore.to_sym
+        if target_class.associations.dig(name, :type) == :has_one
+          return name # rubocop:disable Style/RedundantReturn
         end
       end
     end

data/lib/dynamoid/associations.rb

@@ -265,7 +265,7 @@ module Dynamoid
           @associations[:"#{name}_ids"] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
         end
 
-        define_method("#{name}=".to_sym) do |objects|
+        define_method(:"#{name}=") do |objects|
           @associations[:"#{name}_ids"] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
           @associations[:"#{name}_ids"].setter(objects)
         end

data/lib/dynamoid/components.rb

@@ -11,10 +11,9 @@ module Dynamoid
       extend ActiveModel::Translation
       extend ActiveModel::Callbacks
 
-      define_model_callbacks :create, :save, :destroy, :initialize, :update
+      define_model_callbacks :create, :save, :destroy, :update
+      define_model_callbacks :initialize, :find, :touch, only: :after
 
-      before_create :set_created_at
-      before_save :set_updated_at
       before_save :set_expires_field
       after_initialize :set_inheritance_field
     end

data/lib/dynamoid/config/options.rb

@@ -33,21 +33,21 @@ module Dynamoid
         defaults[name] = settings[name] = options[:default]
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{name}
-            settings[#{name.inspect}]
-          end
+          def #{name}                                               # def endpoint
+            settings[#{name.inspect}]                               #   settings["endpoint"]
+          end                                                       # end
 
-          def #{name}=(value)
-            settings[#{name.inspect}] = value
-          end
+          def #{name}=(value)                                       # def endpoint=(value)
+            settings[#{name.inspect}] = value                       #   settings["endpoint"] = value
+          end                                                       # end
 
-          def #{name}?
-            #{name}
-          end
+          def #{name}?                                              # def endpoint?
+            #{name}                                                 #   endpoint
+          end                                                       # end
 
-          def reset_#{name}
-            settings[#{name.inspect}] = defaults[#{name.inspect}]
-          end
+          def reset_#{name}                                         # def reset_endpoint
+            settings[#{name.inspect}] = defaults[#{name.inspect}]   #   settings["endpoint"] = defaults["endpoint"]
+          end                                                       # end
         RUBY
       end
 

data/lib/dynamoid/config.rb

@@ -59,6 +59,7 @@ module Dynamoid
     option :http_idle_timeout, default: nil     #                                                  - default: 5
     option :http_open_timeout, default: nil     #                                                  - default: 15
     option :http_read_timeout, default: nil     #                                                  - default: 60
+    option :create_table_on_save, default: true
 
     # The default logger for Dynamoid: either the Rails logger or just stdout.
     #