sdbcli 0.1.0

data/README

@@ -0,0 +1,48 @@
+= sdbcli
+
+== Description
+
+sdbcli is command line client of Amazon SimpleDB.
+
+== Source Code
+
+https://bitbucket.org/winebarrel/sdbcli
+
+== Install
+
+  shell> gem install sdbcli
+  shell> export AWS_ACCESS_KEY_ID='...'
+  shell> export AWS_SECRET_ACCESS_KEY='...'
+  shell> export SDB_ENDPOINT='sdb.ap-northeast-1.amazonaws.com'
+  shell> sdbcli
+
+== Example
+
+  ap-northeast-1> help
+  commands:
+    show domains
+    create domain domain_name
+    drop domain domain_name
+    get [output_list] from domain_name where itemname = '...'
+    insert into domain_name (itemname, attr1, attr2, ...) values ('name', 'val1', 'val2', ...)
+    update domain_name set attr1 = 'val1', attr2 = 'val2', ... where itemname = '...'
+    delete [attr1, attr2, ...] from domain_name itemname = '...'
+    select output_list from domain_name [where expression] [sort_instructions] [limit limit]
+  ap-northeast-1> select * from test
+  ---
+  - - itemname1
+    - attr1: val1
+      attr2: val2
+  - - itemname2
+    - attr1: val1
+      attr2: val2
+
+  shell> echo 'select * from test' | sdbcli
+  ---
+  - - itemname1
+    - attr1: val1
+      attr2: val2
+  - - itemname2
+    - attr1: val1
+      attr2: val2
+

data/bin/sdbcli

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+
+require 'rubygems'
+require 'sdbcli'
+
+require 'optparse'
+require 'readline'
+require 'yaml'
+
+access_key_id     = ENV['AWS_ACCESS_KEY_ID']
+secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+sdb_endpoint      = ENV['SDB_ENDPOINT'] || 'sdb.amazonaws.com'
+
+ARGV.options do |opt|
+  opt.on('-k', '--access-key-id=AWS_ACCESS_KEY_ID') {|v| access_key_id = v }
+  opt.on('-s', '--secret-access-key=AWS_SECRET_ACCESS_KEY') {|v| secret_access_key = v }
+  opt.on('-e', '--endpoint=SDB_ENDPOINT') {|v| sdb_endpoint = v }
+  opt.parse!
+
+  unless access_key_id and secret_access_key and sdb_endpoint
+    puts opt.help
+    exit 1
+  end
+end
+
+$runner = SimpleDB::Runner.new(access_key_id, secret_access_key, sdb_endpoint)
+
+def execute(query)
+  out = $runner.execute(query)
+  puts YAML.dump(out) if out
+end
+
+unless $stdin.tty?
+  execute($stdin.read)
+  exit 0
+end
+
+if sdb_endpoint =~ /sdb\.([^.]+)\.amazonaws\.com/
+  region = $1
+else
+  region = 'us-east-1'
+end
+
+def help
+  <<-EOS
+commands:
+  show domains
+  create domain domain_name
+  drop domain domain_name
+  get [output_list] from domain_name where itemname = '...'
+  insert into domain_name (itemname, attr1, attr2, ...) values ('name', 'val1', 'val2', ...)
+  update domain_name set attr1 = 'val1', attr2 = 'val2', ... where itemname = '...'
+  delete [attr1, attr2, ...] from domain_name itemname = '...'
+  select output_list from domain_name [where expression] [sort_instructions] [limit limit]
+    EOS
+end
+
+while buf = Readline.readline("#{region}> ", true)
+  begin
+    case buf.downcase
+    when 'help'
+      puts help
+    when 'exit', 'quit'
+      exit
+    else
+      execute(buf.sub(/;\Z/, ''))
+    end
+  rescue => e
+    puts e.message
+  end
+end

data/lib/sdbcli/sdb-client.rb

@@ -0,0 +1,128 @@
+require 'cgi'
+require 'base64'
+require 'net/https'
+require 'openssl'
+require 'nokogiri'
+
+module SimpleDB
+  class Error < StandardError; end
+
+  class Client
+    API_VERSION = '2009-04-15'
+    SIGNATURE_VERSION = 2
+    SIGNATURE_ALGORITHM = :SHA256
+
+    attr_accessor :endpoint
+
+    def initialize(accessKeyId, secretAccessKey, endpoint = 'sdb.amazonaws.com')
+      @accessKeyId = accessKeyId
+      @secretAccessKey = secretAccessKey
+      @endpoint = endpoint
+    end
+
+    # domain action
+
+    def create_domain(domain_name, params = {})
+      params = params.merge(:DomainName => domain_name)
+      query('CreateDomain', params)
+    end
+
+    def list_domains(params = {})
+      query('ListDomains', params)
+    end
+
+    def delete_domain(domain_name, params = {})
+      params = params.merge(:DomainName => domain_name)
+      query('DeleteDomain', params)
+    end
+
+    # attr action
+
+    def put_attributes(domain_name, item_name, params = {})
+      params = params.merge(:DomainName => domain_name, :ItemName => item_name)
+      query('PutAttributes', params)
+    end
+
+    def get_attributes(domain_name, item_name, params = {})
+      params = params.merge(:DomainName => domain_name, :ItemName => item_name)
+      query('GetAttributes', params)
+    end
+
+    def select(params = {})
+      query('Select', params)
+    end
+
+    def delete_attributes(domain_name, item_name, params = {})
+      params = params.merge(:DomainName => domain_name, :ItemName => item_name)
+      query('DeleteAttributes', params)
+    end
+
+    # batch attr action
+
+    def batch_put_attributes(domain_name, params = {})
+      params = params.merge(:DomainName => domain_name)
+      query('BatchPutAttributes', params)
+    end
+
+    def batch_delete_attributes(domain_name, params = {})
+      params = params.merge(:DomainName => domain_name)
+      query('BatchDeleteAttributes', params)
+    end
+
+    private
+
+    def query(action, params = {})
+      params = {
+        :Action           => action,
+        :Version          => API_VERSION,
+        :Timestamp        => Time.now.getutc.strftime('%Y-%m-%dT%H:%M:%SZ'),
+        :SignatureVersion => SIGNATURE_VERSION,
+        :SignatureMethod  => "Hmac#{SIGNATURE_ALGORITHM}",
+        :AWSAccessKeyId   => @accessKeyId,
+      }.merge(params)
+
+      signature = aws_sign(params)
+      params[:Signature] = signature
+
+      Net::HTTP.version_1_2
+      https = Net::HTTP.new(@endpoint, 443)
+      https.use_ssl = true
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      doc = https.start do |w|
+        req = Net::HTTP::Post.new('/',
+          'Host' => @endpoint,
+          'Content-Type' => 'application/x-www-form-urlencoded'
+        )
+
+        req.set_form_data(params)
+        res = w.request(req)
+
+        Nokogiri::XML(res.body)
+      end
+
+      validate(doc)
+      return doc
+    end
+
+    private
+    def aws_sign(params)
+      params = params.sort_by {|a, b| a.to_s }.map {|k, v| "#{escape(k)}=#{escape(v)}" }.join('&')
+      string_to_sign = "POST\n#{@endpoint}\n/\n#{params}"
+      digest = OpenSSL::HMAC.digest(OpenSSL::Digest.const_get(SIGNATURE_ALGORITHM).new, @secretAccessKey, string_to_sign)
+      Base64.encode64(digest).gsub("\n", '')
+    end
+
+    def validate(doc)
+      if (error = doc.at_css('Errors Error'))
+        code = error.at_css('Code').content
+        message = error.at_css('Message').content
+        raise Error, "#{code}: #{message}"
+      end
+    end
+
+    def escape(str)
+      CGI.escape(str.to_s).gsub('+', '%20')
+    end
+  end # Client
+end # SimpleDB

data/lib/sdbcli/sdb-driver.rb

@@ -0,0 +1,165 @@
+require 'sdbcli/sdb-client'
+
+module SimpleDB
+  class Error < StandardError; end
+
+  class Driver
+    def initialize(accessKeyId, secretAccessKey, endpoint = 'sdb.amazonaws.com')
+      @client = Client.new(accessKeyId, secretAccessKey, endpoint)
+    end
+
+    def endpoint
+      @client.endpoint
+    end
+
+    def endpoint=(v)
+      @client.endpoint = v
+    end
+
+    # domain action
+
+    def create_domain(domain_name)
+      @client.create_domain(domain_name)
+    end
+
+    def show_domains
+      domains = []
+
+      iterate(:list_domains) do |doc|
+        doc.css('DomainName').each do |i|
+          domains << i.content
+        end
+      end
+
+      return domains
+    end
+
+    def drop_domain(domain_name)
+      @client.delete_domain(domain_name)
+    end
+
+    # attr action
+
+    def insert(domain_name, item_name, attrs = {}, consistent = false)
+      params = {:ConsistentRead => consistent}
+      i = 0
+
+      attrs.each do |name, values|
+        [values].flatten.each do |v|
+          i += 1
+          params["Attribute.#{i}.Name"] = name
+          params["Attribute.#{i}.Value"] = v
+          params["Attribute.#{i}.Replace"] = false
+        end
+      end
+
+      @client.put_attributes(domain_name, item_name, params)
+    end
+
+    def update(domain_name, items = {}, consistent = false)
+      params = {:ConsistentRead => consistent}
+      i = j = 0
+
+      items.each do |item_name, attrs|
+        i += 1
+        params["Item.#{i}.ItemName"] = item_name
+
+        (attrs || {}).each do |attr_name, values|
+          [values].flatten.each do |v|
+            j += 1
+            params["Item.#{i}.Attribute.#{j}.Name"] = attr_name
+            params["Item.#{i}.Attribute.#{j}.Value"] = v
+            params["Item.#{i}.Attribute.#{j}.Replace"] = true
+          end
+        end
+      end
+
+      @client.batch_put_attributes(domain_name, params)
+    end
+
+    def get(domain_name, item_name, attr_names = [], consistent = false)
+      params = {:ConsistentRead => consistent}
+      attr_names.each_with_index {|name, i| params["AttributeName.#{i}"] = name }
+      doc = @client.get_attributes(domain_name, item_name, params)
+      attrs_to_hash(doc)
+    end
+
+    def select(expr, consistent = false)
+      params = {:SelectExpression => expr, :ConsistentRead => consistent}
+      items = []
+
+      iterate(:select, params) do |doc|
+        doc.css('Item').map do |i|
+          items << [i.at_css('Name').content, attrs_to_hash(i)]
+        end
+      end
+
+      return items
+    end
+
+    def delete(domain_name, items = {}, consistent = false)
+      params = {:ConsistentRead => consistent}
+      i = j = 0
+
+      items.each do |item_name, attrs|
+        i += 1
+        params["Item.#{i}.ItemName"] = item_name
+
+        (attrs || []).each do |attr_name, values|
+          [values].flatten.each do |v|
+            j += 1
+            params["Item.#{i}.Attribute.#{j}.Name"] = attr_name
+            params["Item.#{i}.Attribute.#{j}.Value"] = v if v
+          end
+        end
+      end
+
+      @client.batch_delete_attributes(domain_name, params)
+    end
+
+    private
+
+    def attrs_to_hash(node)
+      h = {}
+
+      node.css('Attribute').map do |i|
+        name = i.at_css('Name').content
+        value = i.at_css('Value').content
+
+        if h[name].kind_of?(Array)
+          h[name] << value
+        elsif h.has_key?(name)
+          h[name] = [h[name], value]
+        else
+          h[name] = value
+        end
+      end
+
+      return h
+    end
+
+    def iterate(method, params = {})
+      Iterator.new(@client, method, params).each do |doc|
+        yield(doc)
+      end
+    end
+
+    class Iterator
+      def initialize(client, method, params = {})
+        @client = client
+        @method = method
+        @params = params.dup
+        @token = :first
+      end
+
+      def each
+        while @token
+          @params.update(:NextToken => @token.content) if @token != :first
+          doc = @client.send(@method, @params)
+          yield(doc)
+          @token = doc.at_css('NextToken')
+        end
+      end
+    end # Iterator
+  end # Driver
+end # SimpleDB

data/lib/sdbcli/sdb-parser.tab.rb

@@ -0,0 +1,466 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by racc 1.4.5
+# from racc grammer file "sdb-parser.y".
+#
+
+require 'racc/parser'
+
+
+
+require 'strscan'
+
+module SimpleDB
+
+
+class Parser < Racc::Parser
+
+module_eval <<'..end sdb-parser.y modeval..idc908e49d79', 'sdb-parser.y', 119
+
+KEYWORDS = %w(
+  AND
+  ASC
+  BETWEEN
+  BY
+  CREATE
+  DELETE
+  DESC
+  DOMAINS
+  DOMAIN
+  DROP
+  EVERY
+  FROM
+  GET
+  INSERT
+  INTERSECTION
+  INTO
+  IN
+  IS
+  ITEMNAME
+  LIKE
+  LIMIT
+  NOT
+  ORDER
+  OR
+  SET
+  SHOW
+  UPDATE
+  VALUES
+  WHERE
+)
+
+KEYWORD_REGEXP = Regexp.compile("#{KEYWORDS.join '|'}\\b", Regexp::IGNORECASE)
+
+def initialize(obj)
+  src = obj.is_a?(IO) ? obj.read : obj.to_s
+  @ss = StringScanner.new(src)
+end
+
+@@structs = {}
+
+def struct(name, attrs = {})
+  unless (clazz = @@structs[name])
+    clazz = attrs.empty? ? Struct.new(name.to_s) : Struct.new(name.to_s, *attrs.keys)
+    @@structs[name] = clazz
+  end
+
+  obj = clazz.new
+
+  attrs.each do |key, val|
+    obj.send("#{key}=", val)
+  end
+
+  return obj
+end
+private :struct
+
+def scan
+  tok = nil
+
+  until @ss.eos?
+    if (tok = @ss.scan /\s+/)
+      # nothing to do
+    elsif (tok = @ss.scan /(?:!=|>=|<=|>|<|=)/)
+      yield tok, tok
+    elsif (tok = @ss.scan KEYWORD_REGEXP)
+      yield tok.upcase.to_sym, tok
+    elsif (tok = @ss.scan /SELECT\b/i)
+      yield :SELECT, tok + @ss.scan(/.*/)
+    elsif (tok = @ss.scan /NULL\b/i)
+      yield :NULL, nil
+    elsif (tok = @ss.scan /`([^`]|``)*`/)
+      yield :IDENTIFIER, tok.slice(1...-1).gsub(/``/, '`')
+    elsif (tok = @ss.scan /'([^']|'')*'/) #'
+      yield :VALUE, tok.slice(1...-1).gsub(/''/, "'")
+    elsif (tok = @ss.scan /"([^"]|"")*"/) #"
+      yield :VALUE, tok.slice(1...-1).gsub(/""/, '"')
+    elsif (tok = @ss.scan /(0|[1-9]\d*)/)
+      yield :NATURAL_NUMBER, tok.to_i
+    elsif (tok = @ss.scan /[,\(\)\*]/)
+      yield tok, tok
+    elsif (tok = @ss.scan /[a-z_$][0-9a-z_$]*\b/i)
+      yield :IDENTIFIER, tok
+    else
+      raise Racc::ParseError, ('parse error on value "%s"' % @ss.rest.inspect)
+    end
+  end
+
+  yield false, '$'
+end
+private :scan
+
+def parse
+  yyparse self, :scan
+end
+
+def self.parse(obj)
+  self.new(obj).parse
+end
+
+..end sdb-parser.y modeval..idc908e49d79
+
+##### racc 1.4.5 generates ###
+
+racc_reduce_table = [
+ 0, 0, :racc_error,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 1, 27, :_reduce_none,
+ 8, 28, :_reduce_10,
+ 0, 36, :_reduce_11,
+ 1, 36, :_reduce_12,
+ 1, 36, :_reduce_none,
+ 10, 29, :_reduce_14,
+ 3, 38, :_reduce_15,
+ 8, 30, :_reduce_16,
+ 1, 40, :_reduce_17,
+ 3, 40, :_reduce_18,
+ 3, 41, :_reduce_19,
+ 8, 31, :_reduce_20,
+ 0, 42, :_reduce_21,
+ 1, 42, :_reduce_none,
+ 1, 32, :_reduce_23,
+ 3, 33, :_reduce_24,
+ 3, 34, :_reduce_25,
+ 2, 35, :_reduce_26,
+ 1, 37, :_reduce_27,
+ 3, 37, :_reduce_28,
+ 1, 39, :_reduce_29,
+ 3, 39, :_reduce_30 ]
+
+racc_reduce_n = 31
+
+racc_shift_n = 74
+
+racc_action_table = [
+     6,     8,    51,    24,    71,    48,    72,    26,    25,     1,
+    27,    24,    50,    30,    31,    10,    32,    13,    15,    17,
+    33,     3,     5,    34,    35,    36,    34,    37,    38,    39,
+    40,    41,    42,    45,    47,    21,    49,    20,    52,    53,
+    54,    55,    56,    42,    58,    59,    60,    24,    62,    63,
+    64,    65,    34,    66,    67,    68,    70,    19,    73 ]
+
+racc_action_check = [
+     0,     0,    43,     8,    69,    40,    69,     9,     8,     0,
+    10,    13,    43,    17,    19,     0,    20,     0,     0,     0,
+    22,     0,     0,    23,    26,    27,    28,    29,    30,    31,
+    33,    34,    36,    37,    39,     5,    42,     3,    45,    46,
+    47,    48,    49,    50,    51,    52,    53,    54,    55,    58,
+    59,    60,    61,    62,    63,    64,    65,     1,    72 ]
+
+racc_action_pointer = [
+    -2,    45,   nil,    15,   nil,    10,   nil,   nil,    -2,     7,
+     5,   nil,   nil,     6,   nil,   nil,   nil,    -9,   nil,     9,
+    11,   nil,    16,     7,   nil,   nil,    24,     7,    10,    23,
+    23,    16,   nil,    25,    26,   nil,    27,    28,   nil,    27,
+    -1,   nil,    28,    -4,   nil,    32,    25,    24,    34,    33,
+    38,    37,    38,    31,    42,    40,   nil,   nil,    41,    42,
+    38,    36,    44,    45,    46,    47,   nil,   nil,   nil,   -10,
+   nil,   nil,    49,   nil ]
+
+racc_action_default = [
+   -31,   -31,    -6,   -31,    -7,   -31,    -9,    -8,   -11,   -31,
+   -31,    -1,    -2,   -21,    -3,   -23,    -4,   -31,    -5,   -31,
+   -31,   -26,   -31,   -13,   -27,   -12,   -31,   -31,   -22,   -31,
+   -31,   -31,   -25,   -31,   -31,    74,   -31,   -31,   -24,   -31,
+   -31,   -28,   -31,   -31,   -17,   -31,   -31,   -31,   -31,   -31,
+   -31,   -31,   -31,   -31,   -31,   -31,   -19,   -18,   -31,   -31,
+   -31,   -15,   -31,   -31,   -31,   -31,   -10,   -16,   -20,   -31,
+   -29,   -14,   -31,   -30 ]
+
+racc_goto_table = [
+    23,    44,     7,    14,    16,    28,    18,     2,     4,    12,
+    22,     9,    46,    69,    43,    57,    11,    29,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    61 ]
+
+racc_goto_check = [
+    11,    15,     9,     4,     5,    11,     6,     7,     8,     3,
+    10,     1,    12,    13,    14,    15,     2,    16,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    11 ]
+
+racc_goto_pointer = [
+   nil,    11,    16,     9,     3,     4,     6,     7,     8,     2,
+     2,    -8,   -27,   -52,   -22,   -35,     4 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil ]
+
+racc_token_table = {
+ false => 0,
+ Object.new => 1,
+ :use_stmt => 2,
+ :GET => 3,
+ :FROM => 4,
+ :IDENTIFIER => 5,
+ :WHERE => 6,
+ :ITEMNAME => 7,
+ "=" => 8,
+ :VALUE => 9,
+ "*" => 10,
+ :INSERT => 11,
+ :INTO => 12,
+ "(" => 13,
+ ")" => 14,
+ :VALUES => 15,
+ "," => 16,
+ :UPDATE => 17,
+ :SET => 18,
+ :DELETE => 19,
+ :SELECT => 20,
+ :CREATE => 21,
+ :DOMAIN => 22,
+ :DROP => 23,
+ :SHOW => 24,
+ :DOMAINS => 25 }
+
+racc_use_result_var = false
+
+racc_nt_base = 26
+
+Racc_arg = [
+ racc_action_table,
+ racc_action_check,
+ racc_action_default,
+ racc_action_pointer,
+ racc_goto_table,
+ racc_goto_check,
+ racc_goto_default,
+ racc_goto_pointer,
+ racc_nt_base,
+ racc_reduce_table,
+ racc_token_table,
+ racc_shift_n,
+ racc_reduce_n,
+ racc_use_result_var ]
+
+Racc_token_to_s_table = [
+'$end',
+'error',
+'use_stmt',
+'GET',
+'FROM',
+'IDENTIFIER',
+'WHERE',
+'ITEMNAME',
+'"="',
+'VALUE',
+'"*"',
+'INSERT',
+'INTO',
+'"("',
+'")"',
+'VALUES',
+'","',
+'UPDATE',
+'SET',
+'DELETE',
+'SELECT',
+'CREATE',
+'DOMAIN',
+'DROP',
+'SHOW',
+'DOMAINS',
+'$start',
+'stmt',
+'get_stmt',
+'insert_stmt',
+'update_stmt',
+'delete_stmt',
+'select_stmt',
+'create_stmt',
+'drop_stmt',
+'show_stmt',
+'get_output_list',
+'identifier_list',
+'insert_attr_list',
+'value_list',
+'set_clause_list',
+'set_clause',
+'delete_attr_list']
+
+Racc_debug_parser = false
+
+##### racc system variables end #####
+
+ # reduce 0 omitted
+
+ # reduce 1 omitted
+
+ # reduce 2 omitted
+
+ # reduce 3 omitted
+
+ # reduce 4 omitted
+
+ # reduce 5 omitted
+
+ # reduce 6 omitted
+
+ # reduce 7 omitted
+
+ # reduce 8 omitted
+
+ # reduce 9 omitted
+
+module_eval <<'.,.,', 'sdb-parser.y', 17
+  def _reduce_10( val, _values)
+                struct(:GET, :domain => val[3], :item_name => val[7], :attr_names => val[1])
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 22
+  def _reduce_11( val, _values)
+                      []
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 26
+  def _reduce_12( val, _values)
+                      []
+  end
+.,.,
+
+ # reduce 13 omitted
+
+module_eval <<'.,.,', 'sdb-parser.y', 35
+  def _reduce_14( val, _values)
+                attrs = {}
+                val[4].zip(val[8]).each {|k, v| attrs[k] = v }
+                item_name = attrs.delete(:item_name)
+                struct(:INSERT, :domain => val[2], :item_name => item_name, :attrs => attrs)
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 40
+  def _reduce_15( val, _values)
+                       [:item_name, val[2]].flatten
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 47
+  def _reduce_16( val, _values)
+                attrs = {}
+                val[3].each {|k, v| attrs[k] = v }
+                struct(:UPDATE, :domain => val[1], :items => [[val[7], attrs]])
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 52
+  def _reduce_17( val, _values)
+                      [val[0]]
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 56
+  def _reduce_18( val, _values)
+                      val[0] + [val[2]]
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 61
+  def _reduce_19( val, _values)
+                 [val[0], val[2]]
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 66
+  def _reduce_20( val, _values)
+                  struct(:DELETE, :domain => val[3], :items => [[val[7], val[1]]])
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 71
+  def _reduce_21( val, _values)
+                       []
+  end
+.,.,
+
+ # reduce 22 omitted
+
+module_eval <<'.,.,', 'sdb-parser.y', 77
+  def _reduce_23( val, _values)
+                  struct(:SELECT, :query => val[0])
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 82
+  def _reduce_24( val, _values)
+                  struct(:CREATE, :domain => val[2])
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 87
+  def _reduce_25( val, _values)
+                struct(:DROP, :domain => val[2])
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 92
+  def _reduce_26( val, _values)
+                struct(:SHOW, :operand => :domains)
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 97
+  def _reduce_27( val, _values)
+                               [val[0]]
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 101
+  def _reduce_28( val, _values)
+                               val[0] + [val[2]]
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 106
+  def _reduce_29( val, _values)
+                           [val[0]]
+  end
+.,.,
+
+module_eval <<'.,.,', 'sdb-parser.y', 110
+  def _reduce_30( val, _values)
+                          [val[0], val[2]].flatten
+  end
+.,.,
+
+ def _reduce_none( val, _values)
+  val[0]
+ end
+
+end   # class Parser
+
+
+end # module SimpleDB

data/lib/sdbcli/sdb-parser.y

@@ -0,0 +1,222 @@
+class Parser
+options no_result_var
+rule
+  stmt : get_stmt
+       | insert_stmt
+       | update_stmt
+       | delete_stmt
+       | select_stmt
+       | create_stmt
+       | drop_stmt
+       | show_stmt
+       | use_stmt
+
+  get_stmt : GET get_output_list FROM IDENTIFIER WHERE ITEMNAME '=' VALUE
+             {
+                struct(:GET, :domain => val[3], :item_name => val[7], :attr_names => val[1])
+             }
+
+  get_output_list :
+                    {
+                      []
+                    }
+                  | '*'
+                    {
+                      []
+                    }
+                  | identifier_list
+
+  insert_stmt : INSERT INTO IDENTIFIER '(' insert_attr_list ')' VALUES '(' value_list ')'
+              {
+                attrs = {}
+                val[4].zip(val[8]).each {|k, v| attrs[k] = v }
+                item_name = attrs.delete(:item_name)
+                struct(:INSERT, :domain => val[2], :item_name => item_name, :attrs => attrs)
+              }
+
+  insert_attr_list : ITEMNAME ',' identifier_list
+                     {
+                       [:item_name, val[2]].flatten
+                     }
+
+  update_stmt : UPDATE IDENTIFIER SET set_clause_list WHERE ITEMNAME '=' VALUE
+              {
+                attrs = {}
+                val[3].each {|k, v| attrs[k] = v }
+                struct(:UPDATE, :domain => val[1], :items => [[val[7], attrs]])
+              }
+
+  set_clause_list : set_clause
+                    {
+                      [val[0]]
+                    }
+                  | set_clause_list ',' set_clause
+                    {
+                      val[0] + [val[2]]
+                    }
+
+  set_clause : IDENTIFIER '=' VALUE
+               {
+                 [val[0], val[2]]
+               }
+
+  delete_stmt : DELETE delete_attr_list FROM IDENTIFIER WHERE ITEMNAME '=' VALUE
+                {
+                  struct(:DELETE, :domain => val[3], :items => [[val[7], val[1]]])
+                }
+
+  delete_attr_list : 
+                     {
+                       []
+                     }
+                   | identifier_list
+
+  select_stmt : SELECT
+                {
+                  struct(:SELECT, :query => val[0])
+                }
+
+  create_stmt : CREATE DOMAIN IDENTIFIER
+                {
+                  struct(:CREATE, :domain => val[2])
+                }
+
+  drop_stmt : DROP DOMAIN IDENTIFIER
+              {
+                struct(:DROP, :domain => val[2])
+              }
+
+  show_stmt : SHOW DOMAINS
+              {
+                struct(:SHOW, :operand => :domains)
+              }
+
+  identifier_list: IDENTIFIER
+                             {
+                               [val[0]]
+                             }
+                           | identifier_list ',' IDENTIFIER
+                             {
+                               val[0] + [val[2]]
+                             }
+
+  value_list : VALUE
+                         {
+                           [val[0]]
+                         }
+                       | value_list ',' VALUE
+                         {
+                          [val[0], val[2]].flatten
+                         }
+
+---- header
+
+require 'strscan'
+
+module SimpleDB
+
+---- inner
+
+KEYWORDS = %w(
+  AND
+  ASC
+  BETWEEN
+  BY
+  CREATE
+  DELETE
+  DESC
+  DOMAINS
+  DOMAIN
+  DROP
+  EVERY
+  FROM
+  GET
+  INSERT
+  INTERSECTION
+  INTO
+  IN
+  IS
+  ITEMNAME
+  LIKE
+  LIMIT
+  NOT
+  ORDER
+  OR
+  SET
+  SHOW
+  UPDATE
+  VALUES
+  WHERE
+)
+
+KEYWORD_REGEXP = Regexp.compile("#{KEYWORDS.join '|'}\\b", Regexp::IGNORECASE)
+
+def initialize(obj)
+  src = obj.is_a?(IO) ? obj.read : obj.to_s
+  @ss = StringScanner.new(src)
+end
+
+@@structs = {}
+
+def struct(name, attrs = {})
+  unless (clazz = @@structs[name])
+    clazz = attrs.empty? ? Struct.new(name.to_s) : Struct.new(name.to_s, *attrs.keys)
+    @@structs[name] = clazz
+  end
+
+  obj = clazz.new
+
+  attrs.each do |key, val|
+    obj.send("#{key}=", val)
+  end
+
+  return obj
+end
+private :struct
+
+def scan
+  tok = nil
+
+  until @ss.eos?
+    if (tok = @ss.scan /\s+/)
+      # nothing to do
+    elsif (tok = @ss.scan /(?:!=|>=|<=|>|<|=)/)
+      yield tok, tok
+    elsif (tok = @ss.scan KEYWORD_REGEXP)
+      yield tok.upcase.to_sym, tok
+    elsif (tok = @ss.scan /SELECT\b/i)
+      yield :SELECT, tok + @ss.scan(/.*/)
+    elsif (tok = @ss.scan /NULL\b/i)
+      yield :NULL, nil
+    elsif (tok = @ss.scan /`([^`]|``)*`/)
+      yield :IDENTIFIER, tok.slice(1...-1).gsub(/``/, '`')
+    elsif (tok = @ss.scan /'([^']|'')*'/) #'
+      yield :VALUE, tok.slice(1...-1).gsub(/''/, "'")
+    elsif (tok = @ss.scan /"([^"]|"")*"/) #"
+      yield :VALUE, tok.slice(1...-1).gsub(/""/, '"')
+    elsif (tok = @ss.scan /(0|[1-9]\d*)/)
+      yield :NATURAL_NUMBER, tok.to_i
+    elsif (tok = @ss.scan /[,\(\)\*]/)
+      yield tok, tok
+    elsif (tok = @ss.scan /[a-z_$][0-9a-z_$]*\b/i)
+      yield :IDENTIFIER, tok
+    else
+      raise Racc::ParseError, ('parse error on value "%s"' % @ss.rest.inspect)
+    end
+  end
+
+  yield false, '$'
+end
+private :scan
+
+def parse
+  yyparse self, :scan
+end
+
+def self.parse(obj)
+  self.new(obj).parse
+end
+
+---- footer
+
+end # module SimpleDB

data/lib/sdbcli/sdb-runner.rb

@@ -0,0 +1,51 @@
+require 'sdbcli/sdb-driver'
+require 'sdbcli/sdb-parser.tab'
+
+module SimpleDB
+  class Error < StandardError; end
+
+  class Runner
+    def initialize(accessKeyId, secretAccessKey, endpoint = 'sdb.amazonaws.com')
+      @driver = Driver.new(accessKeyId, secretAccessKey, endpoint)
+    end
+
+    def endpoint
+      @driver.endpoint
+    end
+
+    def endpoint=(v)
+      @driver.endpoint = v
+    end
+
+    def execute(query)
+      parsed = Parser.parse(query)
+      command = parsed.class.name.split('::').last.to_sym
+
+      case command
+      when :GET
+        @driver.get(parsed.domain, parsed.item_name, parsed.attr_names)
+      when :INSERT
+        @driver.insert(parsed.domain, parsed.item_name, parsed.attrs)
+        nil
+      when :UPDATE
+        @driver.update(parsed.domain, parsed.items)
+        nil
+      when :DELETE
+        @driver.delete(parsed.domain, parsed.items)
+        nil
+      when :SELECT
+        @driver.select(parsed.query)
+      when :CREATE
+        @driver.create_domain(parsed.domain)
+        nil
+      when :DROP
+        @driver.drop_domain(parsed.domain)
+        nil
+      when :SHOW
+        @driver.show_domains
+      else
+        raise 'must not happen'
+      end
+    end
+  end # Runner
+end # SimpleDB

data/lib/sdbcli.rb

@@ -0,0 +1,3 @@
+require 'sdbcli/sdb-client'
+require 'sdbcli/sdb-driver'
+require 'sdbcli/sdb-runner'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: sdbcli
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: sgwr_dts@yahoo.co.jp
+executables: 
+- sdbcli
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- bin/sdbcli
+- lib/sdbcli/sdb-client.rb
+- lib/sdbcli/sdb-driver.rb
+- lib/sdbcli/sdb-parser.tab.rb
+- lib/sdbcli/sdb-parser.y
+- lib/sdbcli/sdb-runner.rb
+- lib/sdbcli.rb
+homepage: https://bitbucket.org/winebarrel/sdbcli
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: sdbcli is command line client of Amazon SimpleDB.
+test_files: []
+