rethinkdb 1.2.0.1

data/lib/tables.rb

@@ -0,0 +1,123 @@
+# 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

@@ -0,0 +1,118 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: rethinkdb
+version: !ruby/object:Gem::Version 
+  hash: 77
+  prerelease: 
+  segments: 
+  - 1
+  - 2
+  - 0
+  - 1
+  version: 1.2.0.1
+platform: ruby
+authors: 
+- Rethinkdb Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-09 00:00:00 Z
+dependencies: []
+
+description: 
+email: bugs@rethinkdb.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/tables.rb
+- lib/jsons.rb
+- lib/query.rb
+- lib/rethinkdb.rb
+- lib/bt.rb
+- lib/writes.rb
+- lib/rql.rb
+- lib/utils.rb
+- lib/protob_compiler.rb
+- lib/net.rb
+- lib/query_language.pb.rb
+- lib/sequence.rb
+- lib/base_classes.rb
+- lib/streams.rb
+- lib/data_collectors.rb
+homepage: http://rethinkdb.com
+licenses: 
+- Apache-2
+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.24
+signing_key: 
+specification_version: 3
+summary: This package provides the Ruby driver library for the RethinkDB database server.
+test_files: []
+