activerecord-alt-mongo-adapter 0.1.0

data/lib/active_mongo/sqlparser.y

@@ -0,0 +1,294 @@
+class SQLParser
+options no_result_var
+rule
+  sql                   : create_statement
+                        | read_statemant
+                        | update_statemant
+                        | delete_statemant
+
+  create_statement      : INSERT INTO id '(' id_list ')' VALUES '(' value_list ')'
+                          {
+                            {:command => :insert, :table => val[2], :column_list => val[4], :value_list => val[8]}
+                          }
+
+  read_statemant        : SELECT select_list FROM id where_clause order_by_clause limit_clause offset_clause
+                          {
+                            {:command => :select, :table => val[3], :select_list => val[1], :condition => val[4], :order => val[5], :limit => val[6], :offset => val[7]}
+                          }
+                        | SELECT DISTINCT id FROM id where_clause
+                          {
+                            {:command => :select, :table => val[4], :select_list => val[2], :distinct => val[2], :condition => val[5]}
+                          }
+                        | SELECT count_clause FROM id where_clause order_by_clause limit_clause offset_clause
+                          {
+                            {:command => :select, :table => val[3], :count => val[1], :condition => val[4], :order => val[5], :limit => val[6], :offset => val[7]}
+                          }
+
+  count_clause          : COUNT '(' count_arg ')'
+                          {
+                            "count_all"
+                          }
+                        | COUNT '(' count_arg ')' AS id
+                          {
+                            val[5]
+                          }
+
+  count_arg             : '*'
+                        | id
+
+  select_list           : '*'
+                          {
+                            []
+                          }
+                        | id_list
+
+  where_clause          :
+                          {
+                            []
+                          }
+                        | WHERE id_search_condition
+                          {
+                            val[1]
+                          }
+                        | WHERE search_condition
+                          {
+                            val[1]
+                          }
+
+  id_search_condition   : id_predicate
+                        | '(' id_predicate ')'
+                          {
+                            val[1]
+                          }
+
+  id_predicate          : ID '=' value
+                          {
+                            val[2]
+                          }
+                        |  ID IN '(' value_list ')'
+                          {
+                            val[3]
+                          }
+
+  search_condition      : boolean_primary
+                          {
+                            [val[0]].flatten
+                          }
+                        | search_condition AND boolean_primary
+                          {
+                            (val[0] << val[2]).flatten
+                          }
+
+  boolean_primary       : predicate
+                        | '(' search_condition ')'
+                          {
+                            val[1]
+                          }
+
+  predicate             : id op value
+                          {
+                            {:name => val[0], :op => val[1], :expr => val[2]}
+                          }
+                        | NOT id op value
+                          {
+                            {:name => val[1], :op => val[2], :expr => val[3], :not => true}
+                          }
+                        | id op '(' value_list ')'
+                          {
+                            {:name => val[0], :op => val[1], :expr => val[3]}
+                          }
+                        | NOT id op '(' value_list ')'
+                          {
+                            {:name => val[1], :op => val[2], :expr => val[4], :not => true}
+                          }
+                        | between_predicate
+                        | not_in_predicate
+
+  between_predicate     : id BETWEEN value AND value
+                          {
+                            {:name => val[0], :op => '$bt', :expr => [val[2], val[4]]}
+                          }
+
+  not_in_predicate     : id NOT IN '(' value_list ')'
+                          {
+                            {:name => val[0], :op => '$nin', :expr => val[4]}
+                          }
+
+  order_by_clause       :
+                          {
+                            nil
+                          }
+                        | ORDER BY id ordering_spec
+                          {
+                            {:name => val[2], :type => val[3]}
+                          }
+
+  ordering_spec         :
+                          {
+                            :asc
+                          }
+                        | order_spec
+
+  limit_clause          :
+                          {
+                            nil
+                          }
+                        | LIMIT NUMBER
+                          {
+                            val[1]
+                          }
+
+  offset_clause          :
+                          {
+                            nil
+                          }
+                        | OFFSET NUMBER
+                          {
+                            val[1]
+                          }
+
+  update_statemant      : UPDATE id SET set_clause_list where_clause
+                          {
+                            {:command => :update, :table => val[1], :set_clause_list => val[3], :condition => val[4]}
+                          }
+
+  set_clause_list       : set_clause
+                        | set_clause_list ',' set_clause
+                          {
+                            val[0].merge val[2]
+                          }
+
+  set_clause            : id '=' value
+                        {
+                          {val[0] => val[2]}
+                        }
+
+  delete_statemant      : DELETE FROM id where_clause
+                          {
+                            {:command => :delete, :table => val[2], :condition => val[3]}
+                          }
+
+  id                    : IDENTIFIER
+
+  id_list               : id
+                          {
+                            [val[0]]
+                          }
+                        | id_list ',' id
+                          {
+                            val[0] << val[2]
+                          }
+
+  value                 : STRING
+                        | NUMBER
+                        | NULL
+
+  value_list            : value
+                          {
+                            [val[0]]
+                          }
+                        | value_list ',' value
+                          {
+                            val[0] << val[2]
+                          }
+
+  op                    : IN     { '$in'     }
+                        | REGEXP { '$regexp' }
+                        | MOD    { '$mod'    }
+                        | EXISTS { '$exists' }
+                        | '<>'   { '$ne'     }
+                        | '!='   { '$ne'     }
+                        | '>='   { '$gte'    }
+                        | '<='   { '$lte'    }
+                        | '>'    { '$gt'     }
+                        | '<'    { '$lt'     }
+                        | '='    { '$eq'     }
+
+  order_spec            : ASC  { :asc  }
+                        | DESC { :desc }
+
+end
+
+---- header
+
+require 'strscan'
+
+module ActiveMongo
+
+---- inner
+
+KEYWORDS = %w(
+  AND
+  AS
+  ASC
+  BETWEEN
+  BY
+  COUNT
+  DELETE
+  DESC
+  DISTINCT
+  EXISTS
+  FROM
+  IN
+  INSERT
+  INTO
+  LIMIT
+  MOD
+  NOT
+  OFFSET
+  ORDER
+  REGEXP
+  SELECT
+  SET
+  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
+
+def scan
+  piece = 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 /NULL\b/i)
+      yield :NULL, nil
+    elsif (tok = @ss.scan /'(?:[^']|'')*'/) #'
+      yield :STRING, tok.slice(1...-1).gsub(/''/, "'")
+    elsif (tok = @ss.scan /-?(?:0|[1-9]\d*)(?:\.\d+)/)
+      yield :NUMBER, tok.to_f
+    elsif (tok = @ss.scan /-?(?:0|[1-9]\d*)/)
+      yield :NUMBER, tok.to_i
+    elsif (tok = @ss.scan /[,\(\)\*]/)
+      yield tok, tok
+    elsif (tok = @ss.scan /(?:[a-z_]\w+\.|[a-z]\.)*ID\b/i)
+      yield :ID, tok
+    elsif (tok = @ss.scan /(?:[a-z_]\w+\.|[a-z]\.)*(?:[a-z_]\w+|[a-z])/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
+
+---- footer
+
+end # module ActiveMongo

data/lib/active_record/connection_adapters/mongo_adapter.rb

@@ -0,0 +1,184 @@
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'mongo'
+require 'active_mongo/collection'
+require 'active_mongo/sqlparser.tab'
+
+module ActiveRecord
+  class Base
+    def self.mongo_connection(config)
+      config = config.symbolize_keys
+      pair_or_host = config[:host] || 'localhost'
+      port = config[:port] || 27017
+      database = config[:database]
+
+      options = config.dup
+      [:adapter, :host, :port, :database].each {|i| options.delete(i) }
+
+      connection = Mongo::Connection.new(pair_or_host, port, options).db(database)
+      ConnectionAdapters::MongoAdapter.new(connection, logger, config)
+    end
+  end
+
+  module ConnectionAdapters
+    class MongoAdapter < AbstractAdapter
+      def initialize(connection, logger, config)
+        super(connection, logger)
+        @config = config
+      end
+
+      def supports_count_distinct?
+        false
+      end
+
+      def select(sql, name = nil)
+        log(sql, name) do
+          parsed_sql = ActiveMongo::SQLParser.new(sql).parse
+          table = parsed_sql[:table]
+          coll = @connection.collection(table)
+
+          count = parsed_sql[:count]
+          distinct = parsed_sql[:distinct]
+          selector = query2selector(parsed_sql)
+          opts = query2opts(parsed_sql)
+
+          if count and selector.empty? and opts.empty?
+            [{count => coll.count}]
+          elsif distinct
+            coll.distinct(distinct, selector).map do |row|
+              {distinct => row}
+            end
+          else
+            rows = []
+
+            coll.find(selector, opts).each do |row|
+              row['id'] = row['_id'].to_s if row
+              rows << row
+            end
+
+            count ? [{count => rows.length}] : rows
+          end
+        end
+      end
+
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        log(sql, name) do
+          parsed_sql = ActiveMongo::SQLParser.new(sql).parse
+          table, column_list, value_list = parsed_sql.values_at(:table, :column_list, :value_list)
+
+          doc = {}
+          column_list.zip(value_list).each {|k, v| doc[k] = v }
+
+          coll = @connection.collection(table)
+          coll.insert(doc).to_s
+        end
+      end
+
+      def update_sql(sql, name = nil)
+        log(sql, name) do
+          parsed_sql = ActiveMongo::SQLParser.new(sql).parse
+          table = parsed_sql[:table]
+          coll = @connection.collection(table)
+          selector = query2selector(parsed_sql)
+          set_clause_list = parsed_sql[:set_clause_list]
+          doc = {}
+
+          set_clause_list.each do |k, v|
+            k = k.split('.').last
+            doc[k] = v
+          end
+
+          coll.update(selector, {'$set' => doc}, :multi => true)
+        end
+
+        # XXX:
+        1
+      end
+
+      def delete_sql(sql, name = nil)
+        log(sql, name) do
+          parsed_sql = ActiveMongo::SQLParser.new(sql).parse
+          table = parsed_sql[:table]
+          coll = @connection.collection(table)
+          selector = query2selector(parsed_sql)
+          coll.remove(selector)
+        end
+
+        # XXX:
+        1
+      end
+
+      private
+      def query2selector(parsed_sql)
+        condition = parsed_sql[:condition]
+        condition ||= []
+        selector = {}
+
+        if is_cond?(condition)
+          condition.each do |c|
+            name, op, expr, has_not = c.values_at(:name, :op, :expr, :not)
+            name = name.split('.').last
+            op_expr = nil
+
+            case op
+            when '$eq'
+              op_expr = expr
+            when '$regexp'
+              op_expr = Regexp.compile(expr)
+            when '$bt'
+              op_expr = {'$gte' => expr[0], '$lte' => expr[1]}
+            when '$exists'
+              op_expr = {'$exists' => !(expr =~ /f|false/i)}
+            else
+              op_expr = {op => expr}
+            end
+
+            if has_not
+              if op == '$eq'
+                op_expr = {'$ne' => expr}
+              elsif op == '$ne'
+                op_expr = expr
+              else
+                op_expr = {'$not' => op_expr}
+              end
+            end
+
+            if selector[name].kind_of?(Hash) and op_expr.kind_of?(Hash)
+              selector[name] = selector[name].merge(op_expr)
+            else
+              selector[name] = op_expr
+            end
+          end
+        else
+          selector['_id'] = {'$in' => [condition].flatten.map {|i| Mongo::ObjectID.from_string(i) }}
+        end
+
+        selector
+      end
+
+      def query2opts(parsed_sql)
+        order, limit, offset = parsed_sql.values_at(:order, :limit, :offset)
+        opts = {}
+
+        if order
+          name, type = order.values_at(:name, :type)
+          opts[:sort] = [name, type]
+        end
+
+        if limit
+          opts[:limit] = limit.to_i
+        end
+
+        if offset
+          opts[:skip] = offset.to_i
+        end
+
+        opts
+      end
+
+      def is_cond?(condition)
+        condition.kind_of?(Array) and condition.all? {|i| i.kind_of?(Hash) }
+      end
+    end
+  end
+end