/// <summary>
/// <para>Test if two values are not equal.</para>
/// </summary>
/// <example><para>Example: Does 2 not equal 2?</para>
/// <code>r.expr(2).ne(2).run(conn, callback)
/// </code></example>
public Ne ne ( Object exprA, params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAdd(exprA);
arguments.CoerceAndAddAll(exprs);
return new Ne (arguments );
}
/// <summary>
/// <para>The opposite of pluck; takes an object or a sequence of objects, and returns them with
/// the specified paths removed.</para>
/// </summary>
/// <example><para>Example: Since we don't need it for this computation we'll save bandwidth and leave
/// out the list of IronMan's romantic conquests.</para>
/// <code>r.table('marvel').get('IronMan').without('personalVictoriesList').run(conn, callback)
/// </code></example>
public Without without ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new Without (arguments );
}
/// <summary>
/// <para>Compute the logical "and" of two or more values.</para>
/// </summary>
/// <example><para>Example: Return whether both <code>a</code> and <code>b</code> evaluate to true.</para>
/// <code>var a = true, b = false;
/// r.expr(a).and(b).run(conn, callback);
/// // result passed to callback
/// false
/// </code></example>
public And and ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new And (arguments );
}
/// <summary>
/// <para>Get all documents where the given value matches the value of the requested index.</para>
/// </summary>
/// <example><para>Example: Secondary index keys are not guaranteed to be unique so we cannot query via <a href="/api/javascript/get/">get</a> when using a secondary index.</para>
/// <code>r.table('marvel').getAll('man_of_steel', {index:'code_name'}).run(conn, callback)
/// </code></example>
/// <param name="args">Same as calling params object[] overload, except the collection is applied as object[] params.</param>
public GetAll GetAll ( ICollection<Guid> args )
{
var arguments = new Arguments(this);
arguments.CoerceAndAddAll(args);
return new GetAll (arguments);
}
/// <summary>
/// <para>Plucks out one or more attributes from either an object or a sequence of objects
/// (projection).</para>
/// </summary>
/// <example><para>Example: We just need information about IronMan's reactor and not the rest of the
/// document.</para>
/// <code>r.table('marvel').get('IronMan').pluck('reactorState', 'reactorPower').run(conn, callback)
/// </code></example>
public Pluck pluck ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new Pluck (arguments );
}
/// <summary>
/// <para>Concatenate two or more sequences.</para>
///</summary>
/// <example><para>Example: Construct a stream of all heroes.</para>
/// <code>r.table('marvel').union(r.table('dc')).run(conn, callback);
/// </code></example>
public Union union ( params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAddAll(exprs);
return new Union (arguments);
}
/// <summary>
/// <para>Compute the logical "or" of two or more values.</para>
///</summary>
/// <example><para>Example: Return whether either <code>a</code> or <code>b</code> evaluate to true.</para>
/// <code>var a = true, b = false;
/// r.expr(a).or(b).run(conn, callback);
/// // result passed to callback
/// true
/// </code></example>
public Or or ( Object expr, Object exprA, params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAdd(expr);
arguments.CoerceAndAdd(exprA);
arguments.CoerceAndAddAll(exprs);
return new Or (arguments);
}
/// <summary>
/// <para>Test if an object has one or more fields. An object has a field if it has that key and the key has a non-null value. For instance, the object <code>{'a': 1,'b': 2,'c': null}</code> has the fields <code>a</code> and <code>b</code>.</para>
/// </summary>
/// <example><para>Example: Return the players who have won games.</para>
/// <code>r.table('players').hasFields('games_won').run(conn, callback)
/// </code></example>
/// <param name="args">Same as calling params object[] overload, except the collection is applied as object[] params.</param>
public HasFields HasFields ( ICollection<string> args )
{
var arguments = new Arguments(this);
arguments.CoerceAndAddAll(args);
return new HasFields (arguments);
}
/// <summary>
/// <para>Plucks out one or more attributes from either an object or a sequence of objects
/// (projection).</para>
/// </summary>
/// <example><para>Example: We just need information about IronMan's reactor and not the rest of the
/// document.</para>
/// <code>r.table('marvel').get('IronMan').pluck('reactorState', 'reactorPower').run(conn, callback)
/// </code></example>
/// <param name="args">Same as calling params object[] overload, except the collection is applied as object[] params.</param>
public Pluck Pluck ( ICollection<string> args )
{
var arguments = new Arguments(this);
arguments.CoerceAndAddAll(args);
return new Pluck (arguments);
}
/// <summary>
/// <para>Perform a branching conditional equivalent to <code>if-then-else</code>.</para>
/// <para>The <code>branch</code> command takes 2n+1 arguments: pairs of conditional expressions and commands to be executed if the conditionals return any value but <code>false</code> or <code>null</code> (i.e., "truthy" values), with a final "else" command to be evaluated if all of the conditionals are <code>false</code> or <code>null</code>.</para>
///</summary>
/// <example><para>Example: Test the value of x.</para>
/// <code>var x = 10;
/// r.branch(r.expr(x).gt(5), 'big', 'small').run(conn, callback);
/// // Result passed to callback
/// "big"
/// </code></example>
public Branch Branch ( Object expr, Object exprA, Object exprB, params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAdd(expr);
arguments.CoerceAndAdd(exprA);
arguments.CoerceAndAdd(exprB);
arguments.CoerceAndAddAll(exprs);
return new Branch (arguments);
}
/// <summary>
/// <para>Compute the logical "or" of one or more values.</para>
///</summary>
/// <example><para>Example: Return whether either <code>a</code> or <code>b</code> evaluate to true.</para>
/// <code>var a = true, b = false;
/// r.expr(a).or(b).run(conn, callback);
/// // result passed to callback
/// true
/// </code></example>
public Or Or ( params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAddAll(exprs);
return new Or (arguments);
}
/// <summary>
/// <para>Wait for the specified indexes on this table to be ready, or for all
/// indexes on this table to be ready if no indexes are specified.</para>
/// </summary>
/// <example><para>Example: Wait for all indexes on the table <code>test</code> to be ready:</para>
/// <code>r.table('test').indexWait().run(conn, callback)
/// </code>
/// <para>Example: Wait for the index <code>timestamp</code> to be ready:</para>
/// <code>r.table('test').indexWait('timestamp').run(conn, callback)
/// </code></example>
public IndexWait indexWait ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new IndexWait (arguments);
}
/// <summary>
/// <para>Get all documents where the given value matches the value of the requested index.</para>
/// </summary>
/// <example><para>Example: Secondary index keys are not guaranteed to be unique so we cannot query via <a href="/api/javascript/get/">get</a> when using a secondary index.</para>
/// <code>r.table('marvel').getAll('man_of_steel', {index:'code_name'}).run(conn, callback)
/// </code></example>
public GetAll getAll ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new GetAll (arguments);
}
/// <summary>
/// <para>Wait for the specified indexes on this table to be ready, or for all
/// indexes on this table to be ready if no indexes are specified.</para>
/// </summary>
/// <example><para>Example: Wait for all indexes on the table <code>test</code> to be ready:</para>
/// <code>r.table('test').indexWait().run(conn, callback)
/// </code></example>
/// <param name="args">Same as calling params object[] overload, except the collection is applied as object[] params.</param>
public IndexWait IndexWait ( ICollection<string> args )
{
var arguments = new Arguments(this);
arguments.CoerceAndAddAll(args);
return new IndexWait (arguments);
}
/// <summary>
/// <para>Construct a geometry object of type Polygon. The Polygon can be specified in one of two ways:</para>
/// <ul>
/// <li>Three or more two-item arrays, specifying longitude and latitude numbers of the polygon's vertices;</li>
/// <li>Three or more <a href="/api/javascript/point">Point</a> objects specifying the polygon's vertices.</li>
/// </ul>
///</summary>
/// <example><para>Example: Define a polygon.</para>
/// <code>r.table('geo').insert({
/// id: 101,
/// rectangle: r.polygon(
/// [-122.423246,37.779388],
/// [-122.423246,37.329898],
/// [-121.886420,37.329898],
/// [-121.886420,37.779388]
/// )
/// }).run(conn, callback);
/// </code></example>
public Polygon polygon ( Object expr, Object exprA, Object exprB, params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAdd(expr);
arguments.CoerceAndAdd(exprA);
arguments.CoerceAndAdd(exprB);
arguments.CoerceAndAddAll(exprs);
return new Polygon (arguments);
}
/// <summary>
/// <para>The opposite of pluck; takes an object or a sequence of objects, and returns them with
/// the specified paths removed.</para>
/// </summary>
/// <example><para>Example: Since we don't need it for this computation we'll save bandwidth and leave
/// out the list of IronMan's romantic conquests.</para>
/// <code>r.table('marvel').get('IronMan').without('personalVictoriesList').run(conn, callback)
/// </code></example>
/// <param name="args">Same as calling params object[] overload, except the collection is applied as object[] params.</param>
public Without Without ( ICollection<string> args )
{
var arguments = new Arguments(this);
arguments.CoerceAndAddAll(args);
return new Without (arguments);
}
/// <summary>
/// <para>Creates an object from a list of key-value pairs, where the keys must
/// be strings. <code>r.object(A, B, C, D)</code> is equivalent to
/// <code>r.expr([[A, B], [C, D]]).coerce_to('OBJECT')</code>.</para>
///</summary>
/// <example><para>Example: Create a simple object.</para>
/// <code>r.object('id', 5, 'data', ['foo', 'bar']).run(conn, callback)
/// </code></example>
public ReqlObject object_ ( params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAddAll(exprs);
return new ReqlObject (arguments);
}
public Funcall Do_ ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new Funcall (arguments );
}
public Funcall do_ ( Object expr, params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAdd(expr);
arguments.CoerceAndAddAll(exprs);
return new Funcall (arguments);
}
/// <summary>
/// <para>Test if an object has one or more fields. An object has a field if it has that key and the key has a non-null value. For instance, the object <code>{'a': 1,'b': 2,'c': null}</code> has the fields <code>a</code> and <code>b</code>.</para>
/// </summary>
/// <example><para>Example: Return the players who have won games.</para>
/// <code>r.table('players').hasFields('games_won').run(conn, callback)
/// </code></example>
public HasFields hasFields ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new HasFields (arguments );
}
/// <summary>
/// <para>Compute the logical "and" of two or more values.</para>
///</summary>
/// <example><para>Example: Return whether both <code>a</code> and <code>b</code> evaluate to true.</para>
/// <code>var a = true, b = false;
/// r.expr(a).and(b).run(conn, callback);
/// // result passed to callback
/// false
/// </code></example>
public And and ( Object expr, params object[] exprs )
{
Arguments arguments = new Arguments();
arguments.CoerceAndAdd(expr);
arguments.CoerceAndAddAll(exprs);
return new And (arguments);
}
/// <summary>
/// <para>Sort the sequence by document values of the given key(s). To specify
/// the ordering, wrap the attribute with either <code>r.asc</code> or <code>r.desc</code>
/// (defaults to ascending).</para>
/// <para>Sorting without an index requires the server to hold the sequence in
/// memory, and is limited to 100,000 documents (or the setting of the <code>arrayLimit</code> option for <a href="/api/javascript/run">run</a>). Sorting with an index can
/// be done on arbitrarily large tables, or after a <code>between</code> command
/// using the same index.</para>
/// </summary>
/// <example><para>Example: Order all the posts using the index <code>date</code>. </para>
/// <code>r.table('posts').orderBy({index: 'date'}).run(conn, callback)
/// </code>
/// <para>The index must have been previously created with <a href="/api/javascript/index_create/">indexCreate</a>.</para>
/// <code>r.table('posts').indexCreate('date').run(conn, callback)
/// </code>
/// <para>You can also select a descending ordering:</para>
/// <code>r.table('posts').orderBy({index: r.desc('date')}).run(conn, callback)
/// </code></example>
public OrderBy orderBy ( params object[] exprs )
{
Arguments arguments = new Arguments(this);
arguments.CoerceAndAddAll(exprs);
return new OrderBy (arguments);
}
