sql_build() creates a select_query S3 object, that is rendered to a SQL string by sql_render(). The output from sql_build() is designed to be easy to test, as it's database agnostic, and has a hierarchical structure. Outside of testing, however, you should always call sql_render().

join_query(
  x,
  y,
  vars,
  type = "inner",
  by = NULL,
  suffix = c(".x", ".y"),
  na_matches = FALSE
)

select_query(
  from,
  select = sql("*"),
  where = character(),
  group_by = character(),
  having = character(),
  order_by = character(),
  limit = NULL,
  distinct = FALSE
)

semi_join_query(x, y, anti = FALSE, by = NULL, na_matches = FALSE)

set_op_query(x, y, type = type, all = FALSE)

sql_build(op, con = NULL, ...)

sql_render(query, con = NULL, ..., subquery = FALSE)

sql_optimise(x, con = NULL, ..., subquery = FALSE)

Arguments

op

A sequence of lazy operations

con

A database connection. The default NULL uses a set of rules that should be very similar to ANSI 92, and allows for testing without an active database connection.

...

Other arguments passed on to the methods. Not currently used.

subquery

Is this SQL going to be used in a subquery? This is important because you can place a bare table name in a subquery and ORDER BY does not work in subqueries.

Details

sql_build() is generic over the lazy operations, lazy_ops, and generates an S3 object that represents the query. sql_render() takes a query object and then calls a function that is generic over the database. For example, sql_build.op_mutate() generates a select_query, and sql_render.select_query() calls sql_select(), which has different methods for different databases. The default methods should generate ANSI 92 SQL where possible, so you backends only need to override the methods if the backend is not ANSI compliant.