9.3.1

• Use CHAR for GUID and UUID types in MySQL.

• Don't call getUtils from inside QueryUtils.

9.3.0

Make replaceBindings publicly available in QueryUtils.

This is used by qb to inline query bindings in toSQL or dump calls and can be used to inline the bindings in other tools like CommandBox Migrations.

9.2.5

Use named parameters when passing to BaseGrammar. This avoids problems where custom Grammars have extra arguments and we add arguments to the official grammar.

9.2.4

New Features

• Add the ability to pretend to run queries, both in QueryBuilder and SchemaBuilder.

• Add query logging to QueryBuilder and SchemaBuilder instances.

Bug Fixes

• Use varchar for clob when converting to a CFML query. This is used when removing a column like in Oracle pagination.

9.2.3

Handle more numeric SQL types like AtomicInteger and Long.

9.2.2

Add millisecond accuracy to inline bindings.

9.2.1

Separate having bindings from where bindings.

9.2.0

New Features

We now support the returning function inside update and delete statements for supported Grammars. Supported grammars are SQL Server, Postgres, and SQLite.

Bug Fixes

• Fix raw table name parsing in update queries for SqlServerGrammar.

• Fix truncating text in nested wheres inside joins.

• Fix out of order bindings in joinSub

9.1.5

Switch from table_catalog to table_schema when referencing schema for PostgresGrammar.

9.1.4

CommandBox-friendly injections for SQL Commenter.

9.1.3

Add support for from bindings, used especially in fromSub queries.

9.1.2

This release reverts the use of native returntypes. There are too many bugs between engine implementations to make it viable. No end-user changes should be visible.

9.1.1

Make withReturnFormat a public method.

9.1.0

New Features

Add ability to inline bindings when calling toSQL and dump. These strings can be executed in a DBMS application.

Bug Fixes

• Move coldbox namespace injection to the function body so CommandBox doesn't blow up.

• Correctly apply native returntypes after newQuery and withReturnFormat.

9.0.2

• Fix losing defaultOptions when calling newQuery.

• Shortcut for no return format using none.

• Allow for native struct returntypes. Requires a return format of none.

9.0.1

Fix RouteInfoCommenter file name.

9.0.0

Breaking Changes

Dropped support for Adobe ColdFusion 2016

Adobe has ended support for ACF 2016, and so must we.

SchemaBuilder's uuid split into guid() and uuid()

CFML's uuid does not match other languages; it's one character shorter. Because of this, the value from createUUID() cannot be used in some database column types like SQL Server's uniqueidentifier. This made for some confusion in SchemaBuilder since it wasn't clear if uuid meant CFML's definition or the wider world's definition.

So, the types have been split, following Lucee's pattern, into uuid (matching CFML's createUUID()) and guid (matching Java's UUID or createGUID() on Lucee).

Returning all rows from paginate when maxRows is 0 or lower

Popular grid frameworks like Quasar and Datatables use values of 0 or -1 to return all rows from a query. This is now supported in qb. Previously, it generated an invalid query (SELECT * FROM users LIMIT 0 OFFSET 0).

This behavior can be customized by providing a callback to the shouldMaxRowsOverrideToAll setting or init argument. For instance, to revert to the previous behavior you would set the function as follows:

moduleSettings = {
    "qb": {
        "shouldMaxRowsOverrideToAll": function( maxRows ) {
            return false;
        }
    }
};

autoDeriveNumericType is now the default

Introduced in 8.10.0, this feature uses separate SQL types for integers and decimals to increase performance in certain database grammars. This feature is now the default, but the previous behavior can be enabled by setting autoDeriveNumericType to false.

strictDateDetection is now the default

Introduced in 8.1.0, this feature only returns a SQL type of CF_SQL_TIMESTAMP if the param is a date object, not just a string that looks like a date. This helps avoid situations where some strings were incorrectly interpreted as dates. For many, the migration path is straightforward — calls to now() are already date objects as well as any function that operates on a date. If you need to parse a string as a date, the parseDateTime built-in function can accomplish that.

New Features and Improvements

SQLite Grammar Support

Thanks to Jason Steinhouer, qb now supports SQLite for both QueryBuilder and SchemaBuilder. You can use it in your apps by specifying SQLiteGrammar@qb as the default grammar.

sqlCommenter Support

sqlCommenter is a specification by Google for adding contextual information as a comment at the end of a SQL statement. This can give insights into your application, especially when diagnosing slow queries. Examples of the information you can append to your queries are route, handler, action, version, and others, as well as the ability to add your own, such as loggedInUser and more.

sumRaw helper function

There's a new shortcut method to return qb.sum( qb.raw( expression ) ). You're welcome. 😉

Dedicated dropIndex method

Some grammars, like SQL Server, do not treat simple indexes as constraints. For this reason, we've added a dropIndex method alongside the existing dropConstraint.

columnList helper method

columnList will return either an array of column names for the configured table or the query that is generated by cfdbinfo for the configured table. Especially useful when working with dynamically generated grids.

Bug Fixes

• Correctly compile insertUsing statements that use Common Table Expressions (CTEs).

• Update announceInterception calls for ColdBox 7. (Thank you, Michael Born.)

• Fixed insertUsing not placing Common Table Expressions (CTEs) in the correct order.

• Added the missing keyword in the Postgres upsert syntax.

• Don't add DISTINCT when doing a COUNT(*).

• Support aggregates for unioned queries.

8.10.0

• Add a firstOrFail fetch method inspired by Quick.

• There are now specific numeric SQL types for integers and decimals used during the inferSQLType check in QueryUtils. This is an opt-in feature, enabled by setting the autoDeriveNumericType setting. The previous approach was to use CF_SQL_NUMERIC for all numeric types which could cause performance issues in some grammars as they interpreted all CF_SQL_NUMERIC as floating point numbers.

8.9.1

• HOLDLOCK and READPAST are mutually exclusive table locks in SQL Server but were mistakenly being applied together.

8.9.0

• Specify defaultOptions inside of your ColdBox config.

8.8.1

• Better parsing of raw statements when deriving insertUsing columns.

8.8.0

New Features and Improvements

• Insert data based off of a callback or builder using insertUsing.

• Insert data ignoring duplicate key errors using insertIgnore.

• Use a callback or builder as the source for an upsert statement.

• Allow for deleting unmatched source records in upserts (SQL Server only).

• Add a new skipLocked flag to lockForUpdate.

Bug Fixes

• Don't uppercase quoted aliases in Oracle.

• Fix for aliases in update statements.

• Don't sort columns for insertUsing.

• Add subquery bindings in insert and upsert statements.

• Maintain column order when using source in upsert.

8.7.8

• Fix for Oracle returning custom column types when renaming a column.

8.7.7

• Explicit arguments scoping.

8.7.6

• arrayEach is slow compared to merging arrays.

8.7.5

• Fix wheres with joins in update statements.

8.7.2

• Add better null handling to inferSqlType.

8.7.1

• Correctly format columns being updated.

8.7.0

New Features and Improvements

• Add an upsert method. upsert can update or insert multiple records at once depending on if a column is matched.

• Allow expressions in value and values. Also add a valueRaw and valuesRaw helper method to make that pattern more ergonomic.

• Allow JOIN statements in UPDATE statements. (This is not supported on Oracle.)

• Allow updates with subselects using closures or builder instances.

Bug Fixes

• Better handling of group by and having clauses in pagination queries.

• Allow any value to be returned from aggregates including strings, numbers, and dates.

• Provide default values for sum and count if no records are returned.

• Test in CI with full null support.

8.6.1

• Correctly wrap CTE expressions with parenthesis when required in certain grammars.

8.6.0

• SchemaBuilder can now be configured with default query options. (Default options will still be overridden by options passed to each SchemaBuilder method.)

8.5.0

QueryBuilder

• Add a reset method to QueryBuilder.

• Add locking helpers such as lock, noLock, lockForUpdate, and sharedLock.

• Correct return aggregate values for date values from max and min executors.

• Automatically add a scale to an incoming query param when needed.

• Add a whereNotLike shortcut method.

• Correctly format a COUNT(DISTINCT column) query.

• Only use bulk insert syntax when needed in OracleGrammar due to interactions between the result parameter to cfquery, Lucee, and the Oracle JDBC driver.

SchemaBuilder

• Add support for stored computed columns and virtual computed columns.

8.4.9

• Swap master branch to main branch.

8.4.8

• Remove unnecessary injection for QueryUtils.

8.4.7

• Account for raw expressions when generating mementos for comparison

8.4.6

• Add support for mediumtext & longtext types for MySQLGrammar.

8.4.5

• Fix limit on simplePaginate.

8.4.1 - 8.4.4

• Migrate release process to GitHub Actions.

8.4.0

• Add a simplePaginate pagination method for quicker performance when total records or total pages are not needed or too slow.

8.3.0

• Introduce a numericSQLType setting to specify the default numeric SQL type.

8.2.2

• Default to html for the dump format argument to writeDump.

8.2.1

• Correctly use the passed in strictDateDetection to the QueryUtils.cfc.

8.2.0

• Added a dump command to aid in debugging a query while chaining.

8.1.0

• orderByRaw now can accept bindings.

• A new, optional strictDateDetection setting is available to check the underlying Java class of a date object instead of using isDate.

8.0.3

• Ignore select bindings for aggregate queries.

• Allow spaces in table aliases.

• Split FLOAT and DECIMAL column types in SQL Server.

8.0.2

• Clear orderBy bindings when calling clearOrders.

8.0.1

• Trim table definitions before searching for aliases. Makes qb more lenient with extra whitespace.

8.0.0

BREAKING CHANGES

• ``when callbacks now automatically scope and group where clauses when an OR combinator is used.

Other Changes

• Combine clearOrders and orderBy with a new reordermethod.

• Clear current selected columns with clearSelect.

• Combine clearSelect and either select or selectRaw with reselect and reselectRaw respectively.

7.10.0

• Expose nested where functions to enable advanced query manipulation in downstream libraries like Quick.

7.9.9

• Fixes for OracleGrammar including table aliases and wrapped subqueries.

7.9.8

• Allow nullable timestamps in MySQL.

7.9.7

• Return 0 on null aggregates.

7.9.6

• Match type hints to documentation for join functions

7.9.5

• Handle enhanced numeric checks with Secure Profile enabled.

7.9.4

• Allow raw statements in basic where clauses.

7.9.3

• Passed along the options struct to the count method when calling paginate.

7.9.2

• Allow for space-delimited sort directions like column DESC.

• Add helpful message when trying to use a closure with from instead of fromSub.

• ``value and values now work with column formatters.

• Correctly format RETURNING clauses with column formatters and ignoring table qualifiers.

7.9.1

• Handle multi-word columns in queryRemoveColumns.

7.9.0

• Remove elvis operator due to ACF compatibility issues

7.8.0

• Add support for MONEY and SMALLMONEY data types to SchemaBuilder.

7.7.3

• Fix wrapping of enum types for Postgres.

7.7.2

• Compatibility fix for ACF 2018 and listLast parsing.

• Include current_timestamp default for timestamp columns in SchemaBuilder.

• Ignore table qualifiers for insert and update.

7.7.1

• Fix a bug with preventDuplicateJoins when using the closure syntax with a join.

7.7.0

• Add executionTime to the data output from BaseGrammar, including being available in interceptors.

7.6.2

• Fix a case where a column was not wrapped correctly when a where used a subquery for the value.

7.6.1

• Avoid duplicate function due to cbORM / Hibernate bugs when used in the same application.

7.6.0

• Split off a private whereBasic method. This is used in Quick to provide extra sql type features.

• Add a clearOrders method. Any already configured orders are cleared. Any orders added after this call will be added as normal.

• selectRaw now can take an array of expressions.

7.5.1

Fixed an issue using column formatters with update and insert.

7.5.0

Using a new preventDuplicateJoins setting in the module settings, qb can detect duplicate joins and ignore them. This is especially useful in a heavily filtered and dynamic query where you may or may not need the join at all or more than one column may need the same join. preventDuplicateJoins defaults to false, so it is opt-in. It may be turned on by default in a future breaking release of qb.

7.4.0

Enhance order by's with more direction options (c767ac8)

You can now use two shortcut methods: orderByAsc and orderByDesc. Additionally, orderBySub or using orderBy with a closure or builder instance will respect the direction argument.

7.3.15

• Fix using whereBetween with query param structs (07c9b72)

7.3.14

• Ignore orders in aggregate queries (39e1338)

7.3.13

• Format with cfformat (dc2a9b6)

7.3.12

• Improve column wrapping with trimming (d98a5cb)

• Prefer the parent query over magic methods when the parent query has the exact method. (f9fd8d1)

7.3.9, 7.3.10, 7.3.11

• Switch to using ForgeBox Storage.

7.3.8

• Allow passing query options in to paginate (cdecfb3)

7.3.7

• Fix for inserting null values directly (1de27a6)

7.3.5, 7.3.6

• Use cfformat for automatic formatting (119e434)

• Add a type to the onMissingMethod exception (90d1093)

7.3.4

• Correctly wrap comments in MySQLGrammar.

7.3.2, 7.3.3

• Publish qb apidocs to Ortus API Docs.

7.3.1

• Fix for null values breaking the new checkIsActuallyNumeric method in QueryUtils.

7.3.0

• Add a parameterLimit public property to SqlServerGrammar. This property is used in Quick to split up eager loading to work around the 2100 param limit of SQL Server.

7.2.0

• Allow a parent query to be set. A parent query will receive any method calls that are not found on the Query Builder instance. This is especially useful for instances like Quick to allow Quick features like scopes to be available inside any closures.

7.1.0

• Lambdas (arrow functions) are now allowed wherever closures are allowed.

• Add an orderByRaw method.

• Allow for fully-qualified column names (table_name.column.name) in the value and values methods.

7.0.0

BREAKING CHANGES

Please see the Migration Guide for more information on these changes.

• Drop support for Lucee 4.5 and Adobe ColdFusion 11.

• MSSQLGrammar renamed to SqlServerGrammar

• Remove variadic parameters support in builder functions like select.

• The defaultGrammar mapping needs to be the full WireBox mapping, including the @qb, if needed.

  • For instance, MSSQLGrammar would become MSSQLGrammar@qb.

  • This will allow for other grammars to be more easily contributed via third party modules.

• The argument names of forPage changed to match the new paginate method.

• Add defaultValue and optional exception throwing to value. (This changed the argument order.)

• All methods that could conceivably take a subquery as well as a value now accept a closure or another builder instance to use as a subquery. (This changed the argument names in some instances.)

Other Changes

• Completely revamped documentation! (You're looking at it right now.)

• Add new flag to toSQL( showBindings = true ) to replace question marks (?) with cfqueryparam-compatible structs for debugging.

• Preserve column case and order when converting a query to an array using the default "array" return format.

• Add a new paginate method to generate a pagination struct alongside the results. This can be customized using a custom PaginationCollector.

• Allow raw values in insert calls.

• Allow default queryExecute options to be configure at a Query Builder level. This also enables custom QueryBuilders a la Hyper.

• Add a whereLike method.

• Allow closures to be used in left and right joins.

• Provide an addUpdate method to programmatically build the SET clause of an update query.

• Add a new chunk method to grab records from the database in small sets.

• Add raw in alterTable segments.

• Add dropAllObjects support for SqlServerGrammar and OracleGrammar to support migrate fresh from cfmigrations.

• Add a renameTable alias for rename.

• Remove default constraints when dropping columns with a default on SqlServerGrammar.

• Add more column types and column helpers to SchemaBuilder, including:

  • datetimeTz

  • lineString

  • nullableTimestamps

  • point

  • polygon

  • softDeletes

  • softDeletesTz

  • timeTz

  • timestamps

  • timestampTz

  • timestampsTz

  • withCurrent

****

6.4.0

• Allow Expressions (query.raw) in update statements.

Introduction

Using qb, you can:

• Quickly scaffold simple queries

• Make complex, out-of-order queries possible

• Abstract away differences between database engines

Requirements

• Adobe ColdFusion 2018+

• Lucee 5+

qb supports four major database grammars:

• MySQL (MySQLGrammar@qb)

• Oracle (OracleGrammar@qb)

• Postgres (PostgresGrammar@qb)

• Microsoft SQL Server (SqlServerGrammar@qb)

• SQLite (SQLiteGrammar@qb)

Discussion & Help

The Box modules discussion group and community can be found here:

Installation

Code Samples

Compare these two examples:

The differences become even more stark when we introduce more complexity:

With qb you can easily handle setting order by statements before the columns you want or join statements after a where clause:

qb enables you to explore new ways of organizing your code by letting you pass around a query builder object that will compile down to the right SQL without you having to keep track of the order, whitespace, or other SQL gotchas!

Usage

To start a new query, instantiate a new Builder: wirebox.getInstance( "QueryBuilder@qb" ).

By default, qb uses a generic Grammar. You can specify your specific grammar in ColdBox by setting the defaultGrammar in your moduleSettings.

If you are not using WireBox, just make sure to wire up the Builder object with the correct grammar:

v9.0.0

Dropped support for Adobe ColdFusion 2016

Adobe has ended support for ACF 2016, and so must we.

SchemaBuilder's uuid split into and

CFML's uuid does not match other languages; it's one character shorter. Because of this, the value from createUUID() cannot be used in some database column types like SQL Server's uniqueidentifier. This made for some confusion in SchemaBuilder since it wasn't clear if uuid meant CFML's definition or the wider world's definition.

So, the types have been split, following Lucee's pattern, into (matching CFML's ) and (matching Java's UUID or on Lucee).

Returning all rows from when maxRows is 0 or lower

Popular grid frameworks like Quasar and Datatables use values of 0 or -1 to return all rows from a query. This is now supported in qb. Previously, it generated an invalid query (SELECT * FROM users LIMIT 0 OFFSET 0).

This behavior can be customized by providing a callback to the shouldMaxRowsOverrideToAll setting or init argument.

v8.0.0

This isn't a breaking change that will affect most people. In fact, it will most likely improve your code.

Would generate the following SQL:

The problem with this statement is that the OR can short circuit the active check.

The fix is to wrap the LIKE statements in parenthesis. This is done in qb using a function callback to where.

When using the when control flow function, it was easy to miss this. This is because you are already in a closure - it looks the same as when using where to group the clauses.

In qb 8.0.0, when will automatically group added where clauses when needed. That means our original example now produces the SQL we probably expected.

Grouping is not needed if there is no OR combinator. In these cases no grouping is added.

If you had already wrapped your expression in a group inside the when callback, nothing changes. Your code works as before. The OR combinator check only works on the top most level of added where clauses.

Additionally, if you do not add any where clauses inside a when callback, nothing changes from qb 7.

The breaking change part is if you were relying on these statements residing at the same level without grouping. In those cases, you may pass the withoutScoping flag to the when callback.

v7.0.0

Lucee 4.5 and Adobe ColdFusion 11 EOL

Support for Lucee 4.5 and Adobe ColdFusion 11 has been dropped. If you need support for these engines, please remain on an earlier version of qb.

MSSQLGrammar renamed to SqlServerGrammar

MSSQLGrammar was visually too close to MySQLGrammar and was hard to differentiate quickly. SqlServerGrammar is much more unique and easily identifiable. Additionally, more people that use this library refer to their database engine as "SQL Server" than "MSSQL".

Variadic Parameters Support Removed

Variadic parameter support was the ability to pass any number of arguments to certain methods like select.

This code came with a slight performance cost and readability cost. That, combined with the fact that the above syntax is very close to an array, we are dropping support for variadic parameters. To migrate, wrap instances of variadic parameters in an array:

defaultGrammar updated to be the full WireBox mapping

In previous versions, the value passed to defaultGrammar was used to look up a mapping in the @qb namespace. This made it difficult to add or use grammars that weren't part of qb. (You could get around this be registering your custom grammar in the @qb namespace, but doing so seemed strange.)

To migrate this code, change your defaultGrammar to be the full WireBox mapping in your moduleSettings:

value method argument order changed

A defaultValue parameter and optional exception throwing was added to value. This pushed the options struct to the end of the method. If you are using positional parameters with value, you will need to update your method calls to either use named parameters or the new positions.

Some methods renamed callback to query

All methods that could conceivably take a subquery as well as a value now accept a closure or another builder instance to use as a subquery. This led to changing the callback argument to query in the following cases:

• whereSub

• whereInSub

• whereExists

• orWhereExists

• whereNotExists

• andWhereNotExists

• orWhereNotExists

• whereNullSub

• orderBySub

• subSelect

If you are using named parameters with any of the above methods you will need to migrate your method calls.

v5.0.0

Version v5.0.0 brings support for SchemaBuilder inside qb. To avoid naming confusion, Builder was renamed to QueryBuilder. Any references in your code to Builder@qb need to be updated to QueryBuilder@qb.

A query builder is a stateful, transient object. That means that if you want to execute two different queries, you need two separate instances of QueryBuilder.

As such, be careful when injecting QueryBuilder in to a component. If the component is a singleton, you will need to create the QueryBuilder inline or use a provider. This applies to ColdBox handlers as well.

While the above may seem innoculous, it can run in to issues as multiple requests come in to your application. Each request is sharing the same query builder instance and subsequent requests will have unintended results as the where clause keeps growing request after request.

The solution is to either create the QueryBuilder inline, ensuring that each request has its own query to execute:

Or to use a WireBox provider to create a new query each time it is accessed:

newQuery

Once you have access to a QueryBuilder instance, you can create a new query using the same datasource, utils, returnFormat, paginationCollector, columnFormatter, and defaultOptions as the current QueryBuilder instance.

Installation

Installation is easy through and . Simply type box install qb to get started.

Usage

To start a new query, instantiate a new Builder: wirebox.getInstance('QueryBuilder@qb').

By default, qb uses a generic Grammar. You can specify your specific grammar in ColdBox by setting the defaultGrammar in your moduleSettings.

The grammars provided by qb are:

• MySQLGrammar

• OracleGrammar

• PostgresGrammar

• SqlServerGrammar

• SQLiteGrammar

If you are not using WireBox, make sure to wire up the Builder object with the correct grammar:

Configuration Settings

Here are the full configuration settings you can use in the module settings:

SQL Type Inferral

QB binds all parameters by default and guesses the SQL type based on passed values. The default SQL type for numeric values is CF_SQL_NUMERIC, which is a floating point number, for the widest compatibility. This can cause performance problems with large recordsets in some database engines. You can provide a different default in coldbox.cfc if you wish to override this setting:

Integrating With FW/1

Note: These instructions assume a basic knowledge of FW/1, a working FW/1 application structure with qb installed in the /subsystems directory (manually or via CommandBox), and a database configured to run with your application.

Wiring Up With DI/1

Once the application structure is setup, now we need to wire up qb to a bean factory using DI/1.

First we will add a mapping in Application.cfc.

Next we need to tell DI/1 where qb's components are and how to reference them for later use in the application. We can do so by defining the configuration settings in the variables.framework.subsystems struct in Application.cfc. The example below makes use of a load listener to declare each component instance and pass in any constructor arguments.

Usage In Your FW/1 Application

Now that everything is configured, you can launch your application with CommandBox by entering start in the terminal or use whatever method you're accustomed to.

To access qb from your application's code, you can call on it by using getBeanFactory().

We welcome all types of contributions!

The most common type of contribution is to fix an incorrect SQL generation for a database grammar.

To debug what SQL is being ran, you can always call toSQL on any QueryBuilder or SchemaBuilder object. Additionally, you can listen to the preQBExecute interception point for the generated SQL.

Each of the database grammars have two tests — {Grammar}QueryBuilderSpec.cfc and {Grammar}SchemaBuilderSpec.cfc. These tests run the same qb syntax across the different grammars. In each test are methods that return SQL strings like so:

If you find an issue with the SQL generated from a grammar, please file a pull request with the correct SQL in these tests. It's okay if you don't submit a fix as well. (But we'd greatly appreciate it!) Doing so will help expedite the fix.

If you want to add support for a new database grammar, simply copy these two tests from an existing grammar, rename them, change the getBuilder method to return your new grammar, and fill out the SQL as it should be. That will guide your implementation to be 100% compatible with the other grammars in qb.

The orderBy method seems simple but has a lot of depth depending on the type of arguments you pass in.

Order By (String)

query.from( "users" )
    .orderBy( "email" );

SELECT *
FROM `users`
ORDER BY `email` ASC

Calling orderBy multiple times will append to the order list.

query.from( "users" )
    .orderBy( "email" )
    .orderBy( "username", "desc" );

SELECT *
FROM `users`
ORDER BY
  `email` ASC,
  `username` DESC

You can also provide an Expression.

query.from( "users" )
    .orderBy( query.raw( "DATE(created_at)" ) );

SELECT *
FROM `users`
ORDER BY DATE(created_at)

Order By (List)

query.from( "users" )
    .orderBy( "email|asc,username", "desc" );

SELECT *
FROM `users`
ORDER BY
  `email` ASC,
  `username` DESC

Order By (Array of Strings)

query.from( "users" )
    .orderBy( [ "email|asc", "username" ], "desc" );

SELECT *
FROM `users`
ORDER BY
  `email` ASC,
  `username` DESC

Order By (Array of Structs)

query.from( "users" )
    .orderBy( [
        { "column": "email", "direction": "asc" },
        "username"
    ], "desc" );

SELECT *
FROM `users`
ORDER BY
  `email` ASC,
  `username` DESC

Order By (Subquery)

You can order with a subquery using either a function or a QueryBuilder instance.

query.from( "users" )
    .orderBy( function( q ) {
        q.selectRaw( "MAX(created_date)" )
            .from( "logins" )
            .whereColumn( "users.id", "logins.user_id" );
    } );

SELECT *
FROM `users`
ORDER BY (
    SELECT MAX(created_date)
    FROM `logins`
    WHERE `users`.`id` = `logins`.`user_id`
)

Order By Raw

query.from( "users" )
    .orderByRaw( "CASE WHEN status = ? THEN 1 ELSE 0 END DESC", [ 1 ] );

SELECT *
FROM `users`
ORDER BY CASE WHEN status = ? THEN 1 ELSE 0 END DESC

clearOrders

Clears the currently configured orders for the query. Usually used by downstream libraries like Quick.

query.from( "users" )
    .orderBy( "email" )
    .clearOrders();

SELECT *
FROM `users`

reorder

Clears the currently configured orders for the query and sets the new orders passed in. Any valid argument to orderBy can be passed here. Usually used by downstream libraries like Quick.

query.from( "users" )
    .orderBy( "email" )
    .reorder( "username" );

SELECT *
FROM `users`
ORDER BY `username` ASC

Where Methods

where

Adds a where clause to a query.

query.from( "users" )
    .where( "active", "=", 1 );

SELECT *
FROM `users`
WHERE `active` = ?

You can also pass an Expression as the value.

query.from( "users" )
    .where( "last_logged_in", ">", query.raw( "NOW()" ) );

SELECT *
FROM `users`
WHERE `last_logged_in` > NOW()

Any of the following operators can be used in a where clause.

When using the "=" constraint, you can use a shortcut and define the value as the second argument.

query.from( "users" )
    .where( "active", 1 );

SELECT *
FROM `users`
WHERE `active` = ?

To group where statements together, pass a function to the where clause as the only parameter.

query.from( "users" )
    .where( function( q ) {
        q.where( "active", 1 )
            .where( "last_logged_in", ">", dateAdd( "ww", -1, now() ) )
    } );

SELECT *
FROM `users`
WHERE (
    `active` = ?
    AND
    `last_logged_in` > ?
)

A Function or QueryBuilder can be used as a subselect expression when passed to value.

query.from( "users" )
    .where( "email", "foo" )
    .orWhere( "id", "=", function( q ) {
        q.select( q.raw( "MAX(id)" ) )
            .from( "users" )
            .where( "email", "bar" );
    } );

SELECT *
FROM `users`
WHERE `email` = ?
  OR `id` = (
    SELECT MAX(id)
    FROM `users`
    WHERE `email` = ?
  )

andWhere

This method is simply an alias for where with the combinator set to "and".

orWhere

This method is simply an alias for where with the combinator set to "or".

whereBetween

Adds a where between clause to the query.

query.from( "users" )
    .whereBetween( "id", 1, 2 );

SELECT *
FROM `users`
WHERE `id` BETWEEN ? AND ?

If a function or QueryBuilder is passed it is used as a subselect expression.

query.from( "users" )
    .whereBetween(
        "id",
        function( q ) {
            q.select( q.raw( "MIN(id)" ) )
                .from( "users" )
                .where( "email", "bar" );
        },
        builder.newQuery()
            .select( builder.raw( "MAX(id)" ) )
            .from( "users" )
            .where( "email", "bar" )
    );

SELECT *
FROM `users`
WHERE `id` BETWEEN (
    SELECT MIN(id)
    FROM `users`
    WHERE `email` = ?
)
AND (
    SELECT MAX(id)
    FROM `users`
    WHERE `email` = ?
)

whereNotBetween

Adds a where not in clause to the query. This behaves identically to the whereBetween method with the negateflag set to true. See the documentation for whereBetween for usage and examples.

whereColumn

Adds a where clause to a query that compares two columns.

query.from( "users" )
    .whereColumn( "first_name", "=", "last_name" );

SELECT *
FROM `users`
WHERE `first_name` = `last_name`

Just as with where, when using "=" as the operator you can use a shorthand passing the second column in as the operator and leaving the second column null.

query.from( "users" )
    .whereColumn( "first_name", "last_name" );

SELECT *
FROM `users`
WHERE `first_name` = `last_name`

Expressions can be passed in place of either column.

query.from( "users" )
    .whereColumn( "first_name", query.raw( "LOWER(first_name)" ) );

SELECT *
FROM `users`
WHERE `first_name` = LOWER(first_name)

whereExists

Adds a where exists clause to the query.

It can be configured with a function.

query.from( "orders" )
    .whereExists( function( q ) {
        q.select( q.raw( 1 ) )
            .from( "products" )
            .whereColumn( "products.id", "orders.id" );
    } );

SELECT *
FROM `orders`
WHERE EXISTS (
    SELECT 1
    FROM `products`
    WHERE `products`.`id` = `orders`.`id`
)

It can also be configured with a QueryBuilder instance.

var existsQuery = query.newQuery()
    .select( q.raw( 1 ) )
    .from( "products" )
    .whereColumn( "products.id", "orders.id" );

query.from( "orders" )
    .whereExists( existsQuery );

SELECT *
FROM `orders`
WHERE EXISTS (
    SELECT 1
    FROM `products`
    WHERE `products`.`id` = `orders`.`id`
)

whereNotExists

Adds a where not in clause to the query. This behaves identically to the whereExists method with the negateflag set to true. See the documentation for whereExists for usage and examples.

whereLike

A shortcut for calling where with "like" set as the operator.

query.from( "users" )
    .whereLike( "username", "J%" );

SELECT *
FROM `users`
WHERE `username` LIKE ?

whereNotLike

A shortcut for calling where with "not like" set as the operator.

query.from( "users" )
    .whereNotLike( "username", "J%" );

SELECT *
FROM `users`
WHERE `username` NOT LIKE ?

whereIn

Adds a where in clause to the query.

The values passed to whereIn can be a single value, a list of values, or an array of values.

query.from( "orders" )
    .whereIn( "id", [ 1, 4, 66 ] );

SELECT *
FROM `orders`
WHERE `id` IN (?, ?, ?)

If a list of values is passed in, it is converted to an array of values using a single comma (",") delimiter.

query.from( "orders" )
    .whereIn( "id", "1,4,66" );

SELECT *
FROM `orders`
WHERE `id` IN (?, ?, ?)

Any value in the list or array can also be passed using a custom parameter type to have more control over the parameter settings.

query.from( "orders" )
    .whereIn( "id", [ 1, 4, { value = "66", cfsqltype = "CF_SQL_VARCHAR" } ] );

SELECT *
FROM `orders`
WHERE `id` IN (?, ?, ?)

Expressions can be freely mixed in with other values.

query.from( "orders" )
    .whereIn( "id", [ query.raw( "MAX(id)" ), 4, 66 ] );

SELECT *
FROM `orders`
WHERE `id` IN (MAX(id), ?, ?)

A function or QueryBuilder instance can be passed to be used as a subquery expression instead of a list of values.

query.from( "users" )
    .whereIn( "id", function( q ) {
        q.select( "id" )
            .from( "users" )
            .where( "age", ">", 25 );
    } );

SELECT *
FROM `users`
WHERE IN (
    SELECT `id`
    FROM `users`
    WHERE `age` > ?
)

whereNotIn

Adds a where not in clause to the query. This behaves identically to the whereIn method with the negateflag set to true. See the documentation for whereIn for usage and examples.

whereRaw

Shorthand to add a raw SQL statement to the where clauses.

query.from( "users" )
    .whereRaw(
        "id = ? OR email = ? OR is_admin = 1",
        [ 1, "foo" ]
    );

SELECT *
FROM `users`
WHERE id = ? OR email = ? OR is_admin = 1

whereNull

Adds a where null clause to the query.

query.from( "users" )
    .whereNull( "id" );

SELECT *
FROM `users`
WHERE `id` IS NULL

whereNotNull

Adds a where not in clause to the query. This behaves identically to the whereNull method with the negateflag set to true. See the documentation for whereNull for usage and examples.

Dynamic Where Methods

qb uses onMissingMethod to provide a few different helpers when working with where... methods.

andWhere... and orWhere...

Every where... method in qb can be called prefixed with either and or or. Doing so will call the original method using the corresponding combinator.

query.from( "users" )
    .where( "username", "like", "j%" )
    .andWhere( function( q ) {
        q.where( "isSubscribed", 1 )
            .orWhere( "isOnFreeTrial", 1 );
     } );

SELECT *
FROM `users`
WHERE `username` LIKE ?
  AND (
    `isSubscribed` = ?
    OR
    `isOnFreeTrial` = ?
  )

where{Column}

If you call a method starting with where that does not match an existing qb method, qb will instead call the where method using the rest of the method name as the first column name. (The rest of the arguments will be shifted to account for this.) This also applies to andWhere{Column} and orWhere{Column} method signatures.

query.from( "users" )
    .whereUsername( "like", "j%" )
    .whereActive( 1 );

SELECT *
FROM `users`
WHERE `username` LIKE ?
  AND `active` = ?

Join clauses range from simple to complex including joining complete subqueries on multiple conditions. qb has your back with all of these use cases.

join

Applies a join to the query. The simplest join is to a table based on two columns:

query.from( "users" )
    .join( "posts", "users.id", "=", "posts.author_id" );

SELECT *
FROM `users`
JOIN `posts`
  ON `users`.`id` = `posts`.`author_id`

When doing a simple join using = as the operator, you can omit it and pass just the column names:

query.from( "users" )
    .join( "posts", "users.id", "posts.author_id" );

SELECT *
FROM `users`
JOIN `posts`
  ON `users`.`id` = `posts`.`author_id`

``Expressions are also supported as the table argument (though you may prefer the readability of the joinRaw method):

query.from( "users" )
    .join( query.raw( "posts (nolock)" ), "users.id", "=", "posts.author_id" );

SELECT *
FROM [users]
JOIN posts (nolock)
  ON [users].[id] = [posts].[author_id]

When you need to specify more clauses to join, you can pass a function as the second argument:

query.from( "users" )
    .join( "posts", function( j ) {
        j.on( "users.id", "=", "posts.author_id" );
        j.on( "users.prefix", "=", "posts.prefix" );
    } );

SELECT *
FROM `users`
JOIN `posts`
  ON `users`.`id` = `posts`.`author_id`
  AND `users`.`prefix` = `posts`.`prefix`

You can specify where clauses in your joins as well.

query.from( "users" )
    .join( "posts", function( j ) {
        j.on( "users.id", "=", "posts.author_id" );
        j.whereNotNull( "posts.published_date" );
    } );

SELECT *
FROM `users`
JOIN `posts`
  ON `users`.`id` = `posts`.`author_id`
  AND `posts`.`published_date` IS NOT NULL

Conditions inside a join clause can be grouped using a function.

query.from( "users" )
    .join( "posts", function( j ) {
        j.on( function( j1 ) {
            j1.on( "users.id", "posts.author_id" )
                .orOn( "users.id", "posts.reviewer_id" );
        } );
        j.whereNotNull( "posts.published_date" );
    } );