ddbcli 0.1.0

data/lib/ddbcli/cli/options.rb

@@ -0,0 +1,45 @@
+require 'optparse'
+require 'ostruct'
+
+def parse_options
+  options = OpenStruct.new
+  options.access_key_id     = ENV['AWS_ACCESS_KEY_ID']
+  options.secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+  options.ddb_endpoint_or_region =
+    ENV['DDB_ENDPOINT'] || ENV['DDB_REGION'] || 'dynamodb.us-east-1.amazonaws.com'
+
+  # default value
+  options.timeout     = 60
+  options.consistent  = false
+  options.retry_num   = 3
+  options.retry_intvl = 10
+  options.debug       = false
+
+  ARGV.options do |opt|
+    opt.on('-k', '--access-key=ACCESS_KEY')          {|v| options.access_key_id          = v      }
+    opt.on('-s', '--secret-key=SECRET_KEY')          {|v| options.secret_access_key      = v      }
+    opt.on('-r', '--region=REGION_OR_ENDPOINT')      {|v| options.ddb_endpoint_or_region = v      }
+    opt.on('-e', '--eval=COMMAND')                   {|v| options.command                = v      }
+    opt.on('-t', '--timeout=SECOND', Integer)        {|v| options.timeout                = v.to_i }
+    opt.on('',   '--consistent-read')                {    options.consistent             = true   }
+    opt.on('',   '--retry=NUM', Integer)             {|v| options.retry_num              = v.to_i }
+    opt.on('',   '--retry-interval=SECOND', Integer) {|v| options.retry_intvl            = v.to_i }
+    opt.on('',   '--debug')                          {    options.debug                  = true   }
+
+    opt.on('-h', '--help') {
+      puts opt.help
+      puts
+      print_help
+      exit
+    }
+
+    opt.parse!
+
+    unless options.access_key_id and options.secret_access_key and options.ddb_endpoint_or_region
+      puts opt.help
+      exit 1
+    end
+  end
+
+  options
+end

data/lib/ddbcli/ddb-binary.rb

@@ -0,0 +1,15 @@
+module DynamoDB
+  class Binary
+    attr_reader :value
+    alias to_s value
+    alias to_str value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def inspect
+      @value.inspect
+    end
+  end
+end

data/lib/ddbcli/ddb-client.rb

@@ -0,0 +1,239 @@
+require 'json'
+require 'openssl'
+require 'net/http'
+require 'time'
+require 'stringio'
+require 'zlib'
+require 'pp'
+
+require 'ddbcli/ddb-error'
+require 'ddbcli/ddb-endpoint'
+
+module DynamoDB
+  class Client
+
+    SERVICE_NAME = 'dynamodb'
+    API_VERSION  = '2012-08-10'
+    USER_AGENT   = "ddbcli/#{Version}"
+
+    DEFAULT_TIMEOUT = 60
+
+    attr_reader :endpoint
+    attr_reader :region
+    attr_accessor :timeout
+    attr_accessor :retry_num
+    attr_accessor :retry_intvl
+    attr_accessor :debug
+
+    def initialize(accessKeyId, secretAccessKey, endpoint_or_region)
+      @accessKeyId = accessKeyId
+      @secretAccessKey = secretAccessKey
+      set_endpoint_and_region(endpoint_or_region)
+      @timeout = DEFAULT_TIMEOUT
+      @debug = false
+      @retry_num = 3
+      @retry_intvl = 10
+    end
+
+    def set_endpoint_and_region(endpoint_or_region)
+      @endpoint, @region = DynamoDB::Endpoint.endpoint_and_region(endpoint_or_region)
+    end
+
+    def query(action, hash)
+      retry_query do
+        query0(action, hash)
+      end
+    end
+
+    def query0(action, hash)
+      if @debug
+        $stderr.puts(<<EOS)
+---request begin---
+Action: #{action}
+#{hash.pretty_inspect}
+---request end---
+EOS
+      end
+
+      req_body = JSON.dump(hash)
+      date = Time.now.getutc
+
+      headers = {
+        'Content-Type'         => 'application/x-amz-json-1.0',
+        'X-Amz-Target'         => "DynamoDB_#{API_VERSION.gsub('-', '')}.#{action}",
+        'Content-Length'       => req_body.length.to_s,
+        'User-Agent'           => USER_AGENT,
+        'Host'                 => 'dynamodb.us-east-1.amazonaws.com',
+        'X-Amz-Date'           => iso8601(date),
+        'X-Amz-Content-Sha256' => hexhash(req_body),
+        'Accept'               => '*/*',
+        'Accept-Encoding'      => 'gzip',
+     }
+
+      headers['Authorization'] = authorization(date, headers, req_body)
+
+      Net::HTTP.version_1_2
+      https = Net::HTTP.new(@endpoint, 443)
+      https.use_ssl = true
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      https.open_timeout = @timeout
+      https.read_timeout = @timeout
+
+      res_code = nil
+      res_msg  = nil
+
+      res_body = https.start do |w|
+        req = Net::HTTP::Post.new('/', headers)
+        req.body = req_body
+        res = w.request(req)
+
+        res_code = res.code.to_i
+        res_msg  = res.message
+
+        if res['Content-Encoding'] == 'gzip'
+          StringIO.open(res.body, 'rb') do |f|
+            Zlib::GzipReader.wrap(f).read
+          end
+        else
+          res.body
+        end
+      end
+
+      res_data = JSON.parse(res_body)
+
+      if @debug
+        $stderr.puts(<<EOS)
+---response begin---
+#{res_data.pretty_inspect}
+---response end---
+EOS
+      end
+
+      __type = res_data['__type']
+
+      if res_code != 200 or __type
+        errmsg = if __type
+                   if @debug
+                     "#{__type}: #{res_data['message'] || res_data['Message']}"
+                   else
+                     "#{res_data['message'] || res_data['Message']}"
+                   end
+                 else
+                   "#{res_code} #{res_msg}"
+                 end
+
+        raise DynamoDB::Error.new(errmsg, res_data)
+      end
+
+      res_data
+    end
+
+    private
+
+    def authorization(date, headers, body)
+      headers = headers.sort_by {|name, value| name }
+
+      # Task 1: Create a Canonical Request For Signature Version 4
+      # http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+
+      canonicalHeaders = headers.map {|name, value|
+        name.downcase + ':' + value
+      }.join("\n") + "\n"
+
+      signedHeaders = headers.map {|name, value| name.downcase }.join(';')
+
+      canonicalRequest = [
+        'POST', # HTTPRequestMethod
+        '/',    # CanonicalURI
+        '',     # CanonicalQueryString
+        canonicalHeaders,
+        signedHeaders,
+        hexhash(body),
+      ].join("\n")
+
+      # Task 2: Create a String to Sign for Signature Version 4
+      # http://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html
+
+      credentialScope = [
+        date.strftime('%Y%m%d'),
+        @region,
+        SERVICE_NAME,
+        'aws4_request',
+      ].join('/')
+
+      stringToSign = [
+        'AWS4-HMAC-SHA256', # Algorithm
+        iso8601(date),      # RequestDate
+        credentialScope,
+        hexhash(canonicalRequest),
+      ].join("\n")
+
+      # Task 3: Calculate the AWS Signature Version 4
+      # http://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html
+
+      kDate     = hmac('AWS4' + @secretAccessKey, date.strftime('%Y%m%d'))
+      kRegion   = hmac(kDate, @region)
+      kService  = hmac(kRegion, SERVICE_NAME)
+      kSigning  = hmac(kService, 'aws4_request')
+      signature = hexhmac(kSigning, stringToSign)
+
+      'AWS4-HMAC-SHA256 Credential=%s/%s, SignedHeaders=%s, Signature=%s' % [
+        @accessKeyId,
+        credentialScope,
+        signedHeaders,
+        signature,
+      ]
+    end
+
+    def iso8601(utc)
+      utc.strftime('%Y%m%dT%H%M%SZ')
+    end
+
+    def hexhash(data)
+      OpenSSL::Digest::SHA256.new.hexdigest(data)
+    end
+
+    def hmac(key, data)
+      OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, key, data)
+    end
+
+    def hexhmac(key, data)
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, key, data)
+    end
+
+    #def escape(str)
+    #  CGI.escape(str.to_s).gsub('+', '%20')
+    #end
+
+    def retry_query
+      retval = nil
+
+      (@retry_num + 1).times do |i|
+        begin
+          retval = yield
+          break
+        rescue Errno::ETIMEDOUT => e
+          raise e if i >= @retry_num
+        rescue DynamoDB::Error => e
+          if [/\bServiceUnavailable\b/i, /\bexceeded\b/i].any? {|i| i =~ e.message }
+            raise e if i >= @retry_num
+          else
+            raise e
+          end
+        rescue Timeout::Error => e
+          raise e if i >= @retry_num
+        end
+
+        wait_sec = @retry_intvl * (i + 1)
+
+        if @debug
+          $stderr.puts("Retry... (wait %d seconds)" % wait_sec)
+        end
+
+        sleep wait_sec
+      end
+
+      return retval
+    end
+  end # Client
+end # SimpleDB

data/lib/ddbcli/ddb-driver.rb

@@ -0,0 +1,646 @@
+require 'ddbcli/ddb-client'
+require 'ddbcli/ddb-parser.tab'
+require 'ddbcli/ddb-iteratorable'
+
+require 'forwardable'
+
+module DynamoDB
+  class Driver
+    extend Forwardable
+
+    MAX_NUMBER_BATCH_PROCESS_ITEMS = 25
+
+    class Rownum
+      def initialize(rownum)
+        @rownum = rownum
+      end
+
+      def to_i
+        @rownum
+      end
+    end # Rownum
+
+    def initialize(accessKeyId, secretAccessKey, endpoint_or_region)
+      @client = DynamoDB::Client.new(accessKeyId, secretAccessKey, endpoint_or_region)
+      @consistent = false
+    end
+
+    def_delegators(
+      :@client,
+      :endpoint,
+      :region,
+      :timeout, :'timeout=',
+      :set_endpoint_and_region,
+      :retry_num, :'retry_num=',
+      :retry_intvl, :'retry_intvl=',
+      :debug, :'debug=')
+
+    attr_accessor :consistent
+
+    def execute(query, opts = {})
+      parsed, script_type, script = Parser.parse(query)
+      command = parsed.class.name.split('::').last.to_sym
+
+      if command != :NEXT
+        @last_action = nil
+        @last_parsed = nil
+        @last_evaluated_key = nil
+      end
+
+      retval = case command
+               when :SHOW_TABLES
+                 do_show_tables(parsed)
+               when :SHOW_REGIONS
+                 do_show_regions(parsed)
+               when :SHOW_CREATE_TABLE
+                 do_show_create_table(parsed)
+               when :ALTER_TABLE
+                 do_alter_table(parsed)
+               when :USE
+                 do_use(parsed)
+               when :CREATE
+                 do_create(parsed)
+               when :DROP
+                 do_drop(parsed)
+               when :DESCRIBE
+                 do_describe(parsed)
+               when :SELECT
+                 do_select('Query', parsed)
+               when :SCAN
+                 do_select('Scan', parsed)
+               when :GET
+                 do_get(parsed)
+               when :UPDATE
+                 do_update(parsed)
+               when :UPDATE_ALL
+                 do_update_all(parsed)
+               when :DELETE
+                 do_delete(parsed)
+               when :DELETE_ALL
+                 do_delete_all(parsed)
+               when :INSERT
+                 do_insert(parsed)
+               when :NEXT
+                 if @last_action and @last_parsed and @last_evaluated_key
+                   do_select(@last_action, @last_parsed, :last_evaluated_key => @last_evaluated_key)
+                 else
+                   []
+                 end
+               else
+                 raise 'must not happen'
+               end
+
+     begin
+       case script_type
+       when :ruby
+         retval = retval.data if retval.kind_of?(DynamoDB::Iteratorable)
+         retval.instance_eval(script)
+       when :shell
+         retval = retval.data if retval.kind_of?(DynamoDB::Iteratorable)
+         IO.popen(script, "r+") do |f|
+           f.puts(retval.kind_of?(Array) ? retval.map {|i| i.to_s }.join("\n") : retval.to_s)
+           f.close_write
+           f.read
+         end
+       else
+         retval
+       end
+     rescue Exception => e
+       raise DynamoDB::Error, e.message, e.backtrace
+     end
+   end
+
+    private
+
+    def do_show_tables(parsed)
+      req_hash = {}
+      table_names = []
+
+      req_hash['Limit'] = parsed.limit if parsed.limit
+
+      list = lambda do |last_evaluated_table_name|
+        req_hash['ExclusiveStartTableName'] = last_evaluated_table_name if last_evaluated_table_name
+        res_data = @client.query('ListTables', req_hash)
+        table_names.concat(res_data['TableNames'])
+        req_hash['LastEvaluatedTableName']
+      end
+
+      letn = nil
+
+      loop do
+        letn = list.call(letn)
+
+        if parsed.limit or not letn
+          break
+        end
+      end
+
+      return table_names
+    end
+
+    def do_show_regions(parsed)
+      DynamoDB::Endpoint.regions
+    end
+
+    def do_show_create_table(parsed)
+      table_info = @client.query('DescribeTable', 'TableName' => parsed.table)['Table']
+      table_name = table_info['TableName']
+
+      attr_types = {}
+      table_info['AttributeDefinitions'].each do |i|
+        name = i['AttributeName']
+        attr_types[name] = {
+          'S' => 'STRING',
+          'N' => 'NUMBER',
+          'B' => 'BINARY',
+        }.fetch(i['AttributeType'])
+      end
+
+      key_schema = {}
+      table_info['KeySchema'].map do |i|
+        name = i['AttributeName']
+        key_type = i['KeyType']
+        key_schema[name] = key_type
+      end
+
+      indexes = {}
+
+      (table_info['LocalSecondaryIndexes'] || []).each do |i|
+        index_name = i['IndexName']
+        key_name = i['KeySchema'].find {|j| j['KeyType'] == 'RANGE' }['AttributeName']
+        proj_type = i['Projection']['ProjectionType']
+        proj_attrs = i['Projection']['NonKeyAttributes']
+        indexes[index_name] = [key_name, proj_type, proj_attrs]
+      end
+
+      throughput = table_info['ProvisionedThroughput']
+      throughput = {
+        :read  => throughput['ReadCapacityUnits'],
+        :write => throughput['WriteCapacityUnits'],
+      }
+
+      quote = lambda {|i| '`' + i.gsub('`', '``') + '`' } # `
+
+      buf = "CREATE TABLE #{quote[table_name]} ("
+
+      buf << "\n  " + key_schema.map {|name, key_type|
+        attr_type = attr_types[name]
+        "#{quote[name]} #{attr_type} #{key_type}"
+      }.join(",\n  ")
+
+      unless indexes.empty?
+        buf << ",\n  " + indexes.map {|index_name, key_name_proj|
+          key_name, proj_type, proj_attrs = key_name_proj
+          attr_type = attr_types[key_name]
+          index_clause = "INDEX #{quote[index_name]} (#{quote[key_name]} #{attr_type}) #{proj_type}"
+          index_clause << " (#{proj_attrs.join(', ')})" if proj_attrs
+          index_clause
+        }.join(",\n  ")
+      end
+
+      buf << "\n)"
+      buf << ' ' + throughput.map {|k, v| "#{k}=#{v}" }.join(', ')
+      buf << "\n\n"
+
+      return buf
+    end
+
+    def do_alter_table(parsed)
+      req_hash = {
+        'TableName' => parsed.table,
+        'ProvisionedThroughput' => {
+          'ReadCapacityUnits'  => parsed.capacity[:read],
+          'WriteCapacityUnits' => parsed.capacity[:write],
+        },
+      }
+
+      @client.query('UpdateTable', req_hash)
+      nil
+    end
+
+    def do_use(parsed)
+      set_endpoint_and_region(parsed.endpoint_or_region)
+      nil
+    end
+
+    def do_create(parsed)
+      req_hash = {
+        'TableName' => parsed.table,
+        'ProvisionedThroughput' => {
+          'ReadCapacityUnits'  => parsed.capacity[:read],
+          'WriteCapacityUnits' => parsed.capacity[:write],
+        },
+      }
+
+      # hash key
+      req_hash['AttributeDefinitions'] = [
+        {
+          'AttributeName' => parsed.hash[:name],
+          'AttributeType' => parsed.hash[:type],
+        }
+      ]
+
+      req_hash['KeySchema'] = [
+        {
+          'AttributeName' => parsed.hash[:name],
+          'KeyType'       => 'HASH',
+        }
+      ]
+
+      # range key
+      if parsed.range
+        req_hash['AttributeDefinitions'] << {
+          'AttributeName' => parsed.range[:name],
+          'AttributeType' => parsed.range[:type],
+        }
+
+        req_hash['KeySchema'] << {
+          'AttributeName' => parsed.range[:name],
+          'KeyType'       => 'RANGE',
+        }
+      end
+
+      # local secondary index
+      if parsed.indices
+        req_hash['LocalSecondaryIndexes'] = []
+
+        parsed.indices.each do |idx_def|
+          req_hash['AttributeDefinitions'] << {
+            'AttributeName' => idx_def[:key],
+            'AttributeType' => idx_def[:type],
+          }
+
+          local_secondary_index = {
+            'IndexName' => idx_def[:name],
+            'KeySchema' => [
+              {
+                'AttributeName' => parsed.hash[:name],
+                'KeyType'       => 'HASH',
+              },
+              {
+                'AttributeName' => idx_def[:key],
+                'KeyType'       => 'RANGE',
+              },
+            ],
+            'Projection' => {
+              'ProjectionType' => idx_def[:projection][:type],
+            }
+          }
+
+          if idx_def[:projection][:attrs]
+            local_secondary_index['Projection']['NonKeyAttributes'] = idx_def[:projection][:attrs]
+          end
+
+          req_hash['LocalSecondaryIndexes'] << local_secondary_index
+        end
+      end # local secondary index
+
+      @client.query('CreateTable', req_hash)
+      nil
+    end
+
+    def do_drop(parsed)
+      @client.query('DeleteTable', 'TableName' => parsed.table)
+      nil
+    end
+
+    def do_describe(parsed)
+      (@client.query('DescribeTable', 'TableName' => parsed.table) || {}).fetch('Table', {})
+    end
+
+    def do_select(action, parsed, opts = {})
+      req_hash = {'TableName' => parsed.table}
+      req_hash['AttributesToGet'] = parsed.attrs unless parsed.attrs.empty?
+      req_hash['Limit'] = parsed.limit if parsed.limit
+      req_hash['ExclusiveStartKey'] = opts[:last_evaluated_key] if opts[:last_evaluated_key]
+
+      if action == 'Query'
+        req_hash['ConsistentRead'] = @consistent if @consistent
+        req_hash['IndexName'] = parsed.index if parsed.index
+        req_hash['ScanIndexForward'] = parsed.order_asc unless parsed.order_asc.nil?
+      end
+
+      # XXX: req_hash['ReturnConsumedCapacity'] = ...
+
+      if parsed.count
+        req_hash['Select'] = 'COUNT'
+      elsif not parsed.attrs.empty?
+        req_hash['Select'] = 'SPECIFIC_ATTRIBUTES'
+      end
+
+      # key conditions / scan filter
+      if parsed.conds
+        param_name = (action == 'Query') ? 'KeyConditions' : 'ScanFilter'
+        req_hash[param_name] = {}
+
+        parsed.conds.each do |key, operator, values|
+          h = req_hash[param_name][key] = {
+            'ComparisonOperator' => operator.to_s
+          }
+
+          h['AttributeValueList'] = values.map do |val|
+            convert_to_attribute_value(val)
+          end
+        end
+      end # key conditions / scan filter
+
+      res_data = nil
+
+      begin
+        res_data = @client.query(action, req_hash)
+      rescue DynamoDB::Error => e
+        if action == 'Query' and e.data['__type'] == 'com.amazon.coral.service#InternalFailure' and not (e.data['message'] || e.data['Message'])
+          table_info = (@client.query('DescribeTable', 'TableName' => parsed.table) || {}).fetch('Table', {}) rescue {}
+
+          unless table_info.fetch('KeySchema', []).any? {|i| i ||= {}; i['KeyType'] == 'RANGE' }
+            e.message << 'Query can be performed only on a table with a HASH,RANGE key schema'
+          end
+        end
+
+        raise e
+      end
+
+      retval = nil
+
+      if parsed.count
+        retval = res_data['Count']
+      else
+        retval = res_data['Items'].map {|i| convert_to_ruby_value(i) }
+      end
+
+      if res_data['LastEvaluatedKey']
+        @last_action = action
+        @last_parsed = parsed
+        @last_evaluated_key = res_data['LastEvaluatedKey']
+        retval = DynamoDB::Iteratorable.new(retval, res_data['LastEvaluatedKey'])
+      else
+        @last_action = nil
+        @last_parsed = nil
+        @last_evaluated_key = nil
+      end
+
+      return retval
+    end
+
+    def do_get(parsed)
+      req_hash = {'TableName' => parsed.table}
+      req_hash['AttributesToGet'] = parsed.attrs unless parsed.attrs.empty?
+      req_hash['ConsistentRead'] = @consistent if @consistent
+
+      # key
+      req_hash['Key'] = {}
+
+      parsed.conds.each do |key, val|
+        req_hash['Key'][key] = convert_to_attribute_value(val)
+      end # key
+
+      convert_to_ruby_value(@client.query('GetItem', req_hash)['Item'])
+    end
+
+    def do_update(parsed)
+      req_hash = {
+        'TableName' => parsed.table,
+      }
+
+      # key
+      req_hash['Key'] = {}
+
+      parsed.conds.each do |key, val|
+        req_hash['Key'][key] = convert_to_attribute_value(val)
+      end # key
+
+      # attribute updates
+      req_hash['AttributeUpdates'] = {}
+
+      parsed.attrs.each do |attr, val|
+        h = req_hash['AttributeUpdates'][attr] = {}
+
+        if val
+          h['Action'] = parsed.action.to_s.upcase
+          h['Value'] = convert_to_attribute_value(val)
+        else
+          h['Action'] = 'DELETE'
+        end
+      end # attribute updates
+
+      @client.query('UpdateItem', req_hash)
+
+      Rownum.new(1)
+    end
+
+    def do_update_all(parsed)
+      items = scan_for_update(parsed)
+      return Rownum.new(0) if items.empty?
+
+      n = items.length
+
+      items.each do |key_hash|
+        req_hash = {
+          'TableName' => parsed.table,
+        }
+
+        # key
+        req_hash['Key'] = {}
+
+        key_hash.each do |key, val|
+          req_hash['Key'][key] = val
+        end # key
+
+        # attribute updates
+        req_hash['AttributeUpdates'] = {}
+
+        parsed.attrs.each do |attr, val|
+          h = req_hash['AttributeUpdates'][attr] = {}
+
+          if val
+            h['Action'] = parsed.action.to_s.upcase
+            h['Value'] = convert_to_attribute_value(val)
+          else
+            h['Action'] = 'DELETE'
+          end
+        end # attribute updates
+
+        @client.query('UpdateItem', req_hash)
+      end
+
+      Rownum.new(n)
+    end
+
+    def do_delete(parsed)
+      req_hash = {
+        'TableName' => parsed.table,
+      }
+
+      # key
+      req_hash['Key'] = {}
+
+      parsed.conds.each do |key, val|
+        req_hash['Key'][key] = convert_to_attribute_value(val)
+      end # key
+
+      @client.query('DeleteItem', req_hash)
+
+      Rownum.new(1)
+    end
+
+    def do_delete_all(parsed)
+      items = scan_for_update(parsed)
+      return Rownum.new(0) if items.empty?
+
+      n = items.length
+
+      until (chunk = items.slice!(0, MAX_NUMBER_BATCH_PROCESS_ITEMS)).empty?
+        operations = []
+
+        req_hash = {
+          'RequestItems' => {
+            parsed.table => operations,
+          },
+        }
+
+        chunk.each do |key_hash|
+          operations << {
+            'DeleteRequest' => {
+              'Key' => key_hash,
+            },
+          }
+        end
+
+        @client.query('BatchWriteItem', req_hash)
+      end
+
+      Rownum.new(n)
+    end
+
+    def scan_for_update(parsed)
+      # DESCRIBE
+      key_names = @client.query('DescribeTable', 'TableName' => parsed.table)['Table']['KeySchema']
+      key_names = key_names.map {|h| h['AttributeName'] }
+
+      items = []
+
+      # SCAN
+      scan = lambda do |last_evaluated_key|
+        req_hash = {'TableName' => parsed.table}
+        req_hash['AttributesToGet'] = key_names
+        req_hash['Limit'] = parsed.limit if parsed.limit
+        req_hash['Select'] = 'SPECIFIC_ATTRIBUTES'
+        req_hash['ExclusiveStartKey'] = last_evaluated_key if last_evaluated_key
+
+        # XXX: req_hash['ReturnConsumedCapacity'] = ...
+
+        # scan filter
+        if parsed.conds
+          req_hash['ScanFilter'] = {}
+
+          parsed.conds.each do |key, operator, values|
+            h = req_hash['ScanFilter'][key] = {
+              'ComparisonOperator' => operator.to_s
+            }
+
+            h['AttributeValueList'] = values.map do |val|
+              convert_to_attribute_value(val)
+            end
+          end
+        end # scan filter
+
+        res_data = @client.query('Scan', req_hash)
+        items.concat(res_data['Items'])
+        res_data['LastEvaluatedKey']
+      end
+
+      lek = nil
+
+      loop do
+        lek = scan.call(lek)
+        break unless lek
+      end
+
+      return items
+    end
+
+    def convert_to_attribute_value(val)
+      suffix = ''
+      obj = val
+
+      if val.kind_of?(Array)
+        suffix = 'S'
+        obj = val.first
+        val = val.map {|i| i.to_s }
+      else
+        val = val.to_s
+      end
+
+      case obj
+      when DynamoDB::Binary
+        {"B#{suffix}" => val}
+      when String
+        {"S#{suffix}" => val}
+      when Numeric
+        {"N#{suffix}" => val}
+      else
+        raise 'must not happen'
+      end
+    end
+
+    def convert_to_ruby_value(item)
+      h = {}
+
+      (item || {}).sort_by {|a, b| a }.map do |name, val|
+        val = val.map do |val_type, ddb_val|
+          case val_type
+          when 'NS'
+            ddb_val.map {|i| str_to_num(i) }
+          when 'N'
+            str_to_num(ddb_val)
+          else
+            ddb_val
+          end
+        end
+
+        val = val.first if val.length == 1
+        h[name] = val
+      end
+
+      return h
+    end
+
+    def do_insert(parsed)
+      n = 0
+
+      until (chunk = parsed.values.slice!(0, MAX_NUMBER_BATCH_PROCESS_ITEMS)).empty?
+        operations = []
+
+        req_hash = {
+          'RequestItems' => {
+            parsed.table => operations,
+          },
+        }
+
+        chunk.each do |val_list|
+          h = {}
+
+          operations << {
+            'PutRequest' => {
+              'Item' => h,
+            },
+          }
+
+          parsed.attrs.zip(val_list).each do |name, val|
+            h[name] = convert_to_attribute_value(val)
+          end
+        end
+
+        @client.query('BatchWriteItem', req_hash)
+        n += chunk.length
+      end
+
+      Rownum.new(n)
+    end
+
+    def str_to_num(str)
+      str =~ /\./ ? str.to_f : str.to_i
+    end
+
+  end # Driver
+end # DynamoDB