rethinkdb 1.2.6.1 → 1.4.0.0

data/lib/tables.rb

@@ -1,123 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  # A database stored on the cluster.  Usually created with the <b>+r+</b>
-  # shortcut, like:
-  #   r.db('test')
-  class Database
-    # Refer to the database named <b>+name+</b>.  Usually you would
-    # use the <b>+r+</b> shortcut instead:
-    #   r.db(name)
-    def initialize(name); @db_name = name.to_s; end
-
-    # Access the table <b>+name+</b> in this database.  For example:
-    #   r.db('test').table('tbl')
-    # May also provide a set of options <b>+opts+</b>.  Right now the only
-    # useful option is :use_outdated:
-    #   r.db('test').table('tbl', {:use_outdated => true})
-    def table(name, opts={:use_outdated => false}); Table.new(@db_name, name, opts); end
-
-    # Create a new table in this database.  You may also optionally
-    # specify the datacenter it should reside in, its primary key, and
-    # its cache size.  For example:
-    #   r.db('db').table_create('tbl', {:datacenter  => 'dc',
-    #                                   :primary_key => 'id',
-    #                                   :cache_size  => 1073741824})
-    # When run, either returns <b>+nil+</b> or throws on error.
-    def table_create(name, optargs={})
-      S.check_opts(optargs, [:datacenter, :primary_key, :cache_size])
-      dc = optargs[:datacenter] || S.skip
-      pkey = optargs[:primary_key] || S.skip
-      cache = optargs[:cache_size] || S.skip
-      BT.alt_inspect(Meta_Query.new [:create_table, dc, [@db_name, name], pkey, cache]) {
-        "db(#{@db_name.inspect}).create_table(#{name.inspect})"
-      }
-    end
-
-    # Drop the table <b>+name+</b> from this database.  When run,
-    # either returns <b>+nil+</b> or throws on error.
-    def table_drop(name)
-      BT.alt_inspect(Meta_Query.new [:drop_table, @db_name, name]) {
-        "db(#{@db_name.inspect}).drop_table(#{name.inspect})"
-      }
-    end
-
-    # List all the tables in this database.  When run, either returns
-    # <b>+nil+</b> or throws on error.
-    def table_list
-      BT.alt_inspect(Meta_Query.new [:list_tables, @db_name]) {
-        "db(#{@db_name.inspect}).list_tables"
-      }
-    end
-
-    def inspect # :nodoc:
-      real_inspect({:str => @db_name})
-    end
-  end
-
-  # A table in a particular RethinkDB database.  If you call a
-  # function from Sequence on it, it will be treated as a
-  # Stream_Expression reading from the table.
-  class Table
-    def inspect # :nodoc:
-      to_mrs.inspect
-    end
-
-    attr_accessor :opts
-    # A table named <b>+name+</b> residing in database
-    # <b>+db_name+</b>.  Usually you would instead write:
-    #   r.db(db_name).table(name)
-    def initialize(db_name, name, opts)
-      @db_name = db_name;
-      @table_name = name;
-      @opts = opts
-      @context = caller
-      S.check_opts(@opts, [:use_outdated])
-      use_od = (@opts.include? :use_outdated) ? @opts[:use_outdated] : S.conn_outdated
-      @body = [:table, @db_name, @table_name, use_od]
-    end
-
-    # Insert one or more rows into the table.  For example:
-    #   table.insert({:id => 0})
-    #   table.insert([{:id => 1}, {:id => 2}])
-    # If you try to insert a
-    # row with a primary key already in the table, you will get back
-    # an error.  For example, if you have a table <b>+table+</b>:
-    #   table.insert([{:id => 1}, {:id => 1}])
-    # Will return something like:
-    #   {'inserted' => 1, 'errors' => 1, 'first_error' => ...}
-    # If you want to overwrite a row, you should specifiy <b>+mode+</b> to be
-    # <b>+:upsert+</b>, like so:
-    #   table.insert([{:id => 1}, {:id => 1}], :upsert)
-    # which will return:
-    #   {'inserted' => 2, 'errors' => 0}
-    # You may also provide a stream.  So to make a copy of a table, you can do:
-    #   r.db_create('new_db').run
-    #   r.db('new_db').table_create('new_table').run
-    #   r.db('new_db').new_table.insert(table).run
-    def insert(rows, mode=:new)
-      raise_if_outdated
-      rows = [rows] if rows.class != Array
-      do_upsert = (mode == :upsert ? true : false)
-      Write_Query.new [:insert, [@db_name, @table_name], rows.map{|x| S.r(x)}, do_upsert]
-    end
-
-    # Get the row  with key <b>+key+</b>.  You may also
-    # optionally specify the name of the attribute to use as your key
-    # (<b>+keyname+</b>), but note that your table must be indexed by that
-    # attribute.  For example, if we have a table <b>+table+</b>:
-    #   table.get(0)
-    def get(key, keyname=:id)
-      Single_Row_Selection.new [:getbykey, [@db_name, @table_name], keyname, S.r(key)]
-    end
-
-    def method_missing(m, *args, &block) # :nodoc:
-      to_mrs.send(m, *args, &block);
-    end
-
-    def to_mrs # :nodoc:
-      BT.alt_inspect(Multi_Row_Selection.new(@body, @context, @opts)) {
-        "db(#{@db_name.inspect}).table(#{@table_name.inspect})"
-      }
-    end
-  end
-end

data/lib/utils.rb

@@ -1,118 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  module C_Mixin #Constants
-    # We often have shorter names for things, or inline variants, specified here.
-    def method_aliases
-      { :attr => :getattr, :attrs => :pickattrs, :attr? => :hasattr,
-        :get => :getattr, :pick => :pickattrs, :has => :hasattr,
-        :equals => :eq, :neq => :ne,
-        :sub => :subtract, :mul => :multiply, :div => :divide, :mod => :modulo,
-        :+ => :add, :- => :subtract, :* => :multiply, :/ => :divide, :% => :modulo,
-        :and => :all, :or => :any, :to_stream => :array_to_stream, :to_array => :stream_to_array} end
-
-    # Allows us to identify protobuf classes which are actually variant types,
-    # and to get their corresponding enums.
-    def class_types
-      { Query => Query::QueryType, WriteQuery => WriteQuery::WriteQueryType,
-        Term => Term::TermType, Builtin => Builtin::BuiltinType,
-        MetaQuery => MetaQuery::MetaQueryType} end
-
-    # The protobuf spec often has a field with a slightly different name from
-    # the enum constant, which we list here.
-    def query_rewrites
-      { :getattr => :attr,
-        :hasattr => :attr,
-        :without => :attrs,
-        :pickattrs => :attrs,
-        :string => :valuestring, :json => :jsonstring, :bool => :valuebool,
-        :if => :if_, :getbykey => :get_by_key, :groupedmapreduce => :grouped_map_reduce,
-        :insertstream => :insert_stream, :foreach => :for_each, :orderby => :order_by,
-        :pointupdate => :point_update, :pointdelete => :point_delete,
-        :pointmutate => :point_mutate, :concatmap => :concat_map,
-        :read => :read_query, :write => :write_query, :meta => :meta_query,
-        :create_db => :db_name, :drop_db => :db_name, :list_tables => :db_name
-      } end
-
-    def name_rewrites
-      { :between => :range, :js => :javascript,
-        :array_to_stream => :arraytostream, :stream_to_array => :streamtoarray,
-        :merge => :mapmerge, :branch => :if, :pick => :pickattrs, :unpick => :without,
-        :replace => :mutate, :pointreplace => :pointmutate, :contains => :hasattr,
-        :count => :length
-      } end
-
-    # These classes go through a useless intermediate type.
-    def trampolines; [:table, :map, :concatmap, :filter] end
-
-    # These classes expect repeating arguments.
-    def repeats; [:insert, :foreach]; end
-
-    # These classes reference a tableref directly, rather than a term.
-    def table_directs
-      [:insert, :insertstream, :pointupdate, :pointdelete, :pointmutate,
-       :create, :drop] end
-
-    def nonatomic_variants
-      [:update_nonatomic, :replace_nonatomic,
-       :pointupdate_nonatomic, :pointreplace_nonatomic] end
-  end
-  module C; extend C_Mixin; end
-
-  module P_Mixin #Protobuf Utils
-    def enum_type(_class, _type); _class.values[_type.to_s.upcase.to_sym]; end
-    def message_field(_class, _type); _class.fields.select{|x,y|
-        y.instance_eval{@name} == _type
-        #TODO: why did the following stop working?  (Or, why did it ever work?)
-        #y.name == _type
-      }[0]; end
-    def message_set(message, key, val); message.send((key.to_s+'=').to_sym, val); end
-  end
-  module P; extend P_Mixin; end
-
-  module S_Mixin #S-expression Utils
-    def rewrite(q); C.name_rewrites[q] || q; end
-    def mark_boolop(x); class << x; def boolop?; true; end; end; x; end
-    def check_opts(opts, set)
-      if (bad_opts = opts.map{|k,_|k} - set) != []
-        raise ArgumentError,"Unrecognized options: #{bad_opts.inspect}"
-      end
-    end
-    @@gensym_counter = 1000
-    def gensym; '_var_'+(@@gensym_counter += 1).to_s; end
-    def with_var
-      sym = gensym
-      yield sym, var(sym)
-    end
-    def var(varname)
-      BT.alt_inspect(Var_Expression.new [:var, varname]) { |expr| expr.body[1] }
-    end
-    def r x; x.equal?(skip) ? x : RQL.expr(x); end
-    def skip; :skip_2222ebd4_2c16_485e_8c27_bbe43674a852; end
-    def conn_outdated; :conn_outdated_2222ebd4_2c16_485e_8c27_bbe43674a852; end
-
-    def arg_or_block(*args, &block)
-      if args.length == 1 && block
-        raise ArgumentError,"Cannot provide both an argument *and* a block."
-      end
-      return lambda { args[0] } if (args.length == 1)
-      return block if block
-      raise ArgumentError,"Must provide either an argument or a block."
-    end
-
-    def clean_lst lst # :nodoc:
-      return lst.sexp if lst.kind_of? RQL_Query
-      return lst.class == Array ? lst.map{|z| clean_lst(z)} : lst
-    end
-
-    def replace(sexp, map)
-      return sexp.map{|x| replace x,map} if sexp.class == Array
-      return (map.include? sexp) ? map[sexp] : sexp
-    end
-
-    def checkdict s
-      return s.to_s if s.class == String || s.class == Symbol
-      raise RuntimeError, "Invalid JSON dict key: #{s.inspect}"
-    end
-  end
-  module S; extend S_Mixin; end
-end

data/lib/writes.rb

@@ -1,24 +0,0 @@
-# Copyright 2010-2012 RethinkDB, all rights reserved.
-module RethinkDB
-  # A write operation, like an insert.
-  class Write_Query < RQL_Query
-    # Internal tool for when we have commands that take a flag but
-    # which are most easily processed by the protobuf compiler as a
-    # separate command.
-    def apply_variant(variant) # :nodoc:
-      return self if variant.nil?
-      if variant == :non_atomic
-        @body[0] = case @body[0]
-                   when :update        then :update_nonatomic
-                   when :replace       then :replace_nonatomic
-                   when :pointupdate   then :pointupdate_nonatomic
-                   when :pointreplace  then :pointreplace_nonatomic
-                   else raise RuntimeError,"#{@body[0]} cannot be made nonatomic"
-                   end
-      else
-        raise RuntimeError,"Unknown variant #{@body[0]}; did you mean `:non_atomic`?"
-      end
-      return self
-    end
-  end
-end