@adonisjs/lucid

import { Knex } from 'knex'; import Macroable from '@poppinss/macroable'; import { ChainableContract, DBQueryCallback } from '../../types/querybuilder.js'; /** * The chainable query builder to construct SQL queries for selecting, updating and * deleting records. * * The API internally uses the knex query builder. However, many of methods may have * different API. */ export declare abstract class Chainable extends Macroable implements ChainableContract { knexQuery: Knex.QueryBuilder; private queryCallback; keysResolver?: ((columnName: string) => string) | undefined; hasAggregates: boolean; hasGroupBy: boolean; hasUnion: boolean; /** * Collection where clauses in a 2nd array. Calling `wrapExisting` * adds a new stack item */ private whereStack; /** * Returns the recent most array from the where stack */ private getRecentStackItem; /** * Returns the wrapping method for a given where method */ private getWrappingMethod; /** * Applies the where clauses */ protected applyWhere(): void; /** * An array of selected columns */ get columns(): ChainableContract['columns']; /** * Custom alias for the query results. Ignored if it not a * subquery */ subQueryAlias?: string; constructor(knexQuery: Knex.QueryBuilder, queryCallback: DBQueryCallback, keysResolver?: ((columnName: string) => string) | undefined); /** * Raises exception when only one argument is passed to a where * clause and it is a string. It means the value is undefined */ private validateWhereSingleArgument; /** * Returns the value pair for the `whereBetween` clause */ private getBetweenPair; /** * Normalizes the columns aggregates functions to something * knex can process. */ private normalizeAggregateColumns; /** * Resolves the column name considering raw queries as well. */ private resolveColumn; /** * Resolves column names */ protected resolveKey(columns: any, checkForObject?: boolean, returnValue?: any): any; /** * Apply existing query flags to a new query builder. This is * done during clone operation */ protected applyQueryFlags(query: Chainable): void; /** * Transforms the value to something that knex can internally understand and * handle. It includes. * * 1. Returning the `knexBuilder` for sub queries. * 2. Returning the `knex.refBuilder` for reference builder. * 2. Returning the `knexBuilder` for raw queries. * 3. Wrapping callbacks, so that the end user receives an instance Lucid query * builder and not knex query builder. */ protected transformValue(value: any): any; /** * Transforms the user callback to something that knex * can internally process */ protected transformCallback(value: any): any; /** * Returns the underlying knex raw query builder for Lucid raw * query builder */ protected transformRaw(value: any): any; /** * Define columns for selection */ select(...args: any[]): this; /** * Select table for the query. Re-calling this method multiple times will * use the last selected table */ from(table: any): this; /** * Wrap existing where clauses to its own group */ wrapExisting(): this; /** * Add a `where` clause */ where(key: any, operator?: any, value?: any): this; /** * Add a `or where` clause */ orWhere(key: any, operator?: any, value?: any): this; /** * Alias for `where` */ andWhere(key: any, operator?: any, value?: any): this; /** * Adding `where not` clause */ whereNot(key: any, operator?: any, value?: any): this; /** * Adding `or where not` clause */ orWhereNot(key: any, operator?: any, value?: any): this; /** * Alias for [[whereNot]] */ andWhereNot(key: any, operator?: any, value?: any): this; /** * Add a where clause on a given column */ whereColumn(column: any, operator: any, comparisonColumn?: any): this; /** * Add a orWhere clause on a given column */ orWhereColumn(column: any, operator: any, comparisonColumn?: any): this; /** * Alias for whereColumn */ andWhereColumn(column: any, operator: any, comparisonColumn?: any): this; /** * Add a whereNot clause on a given column */ whereNotColumn(column: any, operator: any, comparisonColumn?: any): this; /** * Add a orWhereNotColumn clause on a given column */ orWhereNotColumn(column: any, operator: any, comparisonColumn?: any): this; /** * Alias for whereNotColumn */ andWhereNotColumn(column: any, operator: any, comparisonColumn?: any): this; /** * Adding a `where in` clause */ whereIn(columns: any, value: any): this; /** * Adding a `or where in` clause */ orWhereIn(columns: any, value: any): this; /** * Alias for [[whereIn]] */ andWhereIn(key: any, value: any): this; /** * Adding a `where not in` clause */ whereNotIn(columns: any, value: any): this; /** * Adding a `or where not in` clause */ orWhereNotIn(columns: any, value: any): this; /** * Alias for [[whereNotIn]] */ andWhereNotIn(key: any, value: any): this; /** * Adding `where not null` clause */ whereNull(key: any): this; /** * Adding `or where not null` clause */ orWhereNull(key: any): this; /** * Alias for [[whereNull]] */ andWhereNull(key: any): this; /** * Adding `where not null` clause */ whereNotNull(key: any): this; /** * Adding `or where not null` clause */ orWhereNotNull(key: any): this; /** * Alias for [[whereNotNull]] */ andWhereNotNull(key: any): this; /** * Add a `where exists` clause */ whereExists(value: any): this; /** * Add a `or where exists` clause */ orWhereExists(value: any): this; /** * Alias for [[whereExists]] */ andWhereExists(value: any): this; /** * Add a `where not exists` clause */ whereNotExists(value: any): this; /** * Add a `or where not exists` clause */ orWhereNotExists(value: any): this; /** * Alias for [[whereNotExists]] */ andWhereNotExists(value: any): this; /** * Add where between clause */ whereBetween(key: any, value: [any, any]): this; /** * Add where between clause */ orWhereBetween(key: any, value: any): this; /** * Alias for [[whereBetween]] */ andWhereBetween(key: any, value: any): this; /** * Add where between clause */ whereNotBetween(key: any, value: any): this; /** * Add where between clause */ orWhereNotBetween(key: any, value: any): this; /** * Alias for [[whereNotBetween]] */ andWhereNotBetween(key: any, value: any): this; /** * Adding a where clause using raw sql */ whereRaw(sql: any, bindings?: any): this; /** * Adding a or where clause using raw sql */ orWhereRaw(sql: any, bindings?: any): this; /** * Alias for [[whereRaw]] */ andWhereRaw(sql: any, bindings?: any): this; /** * Add a `where like` clause */ whereLike(key: any, value: any): this; /** * Add a `where like` clause */ orWhereLike(key: any, value?: any): this; /** * Add a `where like` clause */ andWhereLike(key: any, value?: any): this; /** * Add a `where like` clause */ whereILike(key: any, value?: any): this; /** * Add a `where like` clause */ orWhereILike(key: any, value?: any): this; /** * Add a `where like` clause */ andWhereILike(key: any, value?: any): this; /** * Define a where clause with value that matches for JSON */ whereJson(column: string, value: any): this; /** * Define a or where clause with value that matches for JSON */ orWhereJson(column: string, value: any): this; /** * Define a where clause with value that matches for JSON * * @alias whereJson */ andWhereJson(column: string, value: any): this; /** * Define a where clause with value that matches for JSON */ whereNotJson(column: string, value: any): this; /** * Define a or where clause with value that matches for JSON */ orWhereNotJson(column: string, value: any): this; /** * Define a where clause with value that matches for JSON * * @alias whereNotJson */ andWhereNotJson(column: string, value: any): this; /** * Define a where clause with value that matches for a superset of * JSON */ whereJsonSuperset(column: string, value: any): this; /** * Define a or where clause with value that matches for a superset of * JSON */ orWhereJsonSuperset(column: string, value: any): this; /** * Define or where clause with value that matches for a superset of * JSON * * @alias whereJsonSuperset */ andWhereJsonSuperset(column: string, value: any): this; /** * Define a where clause with value that matches for a superset of * JSON */ whereNotJsonSuperset(column: string, value: any): this; /** * Define a or where clause with value that matches for a superset of * JSON */ orWhereNotJsonSuperset(column: string, value: any): this; /** * Define or where clause with value that matches for a superset of * JSON * * @alias whereNotJsonSuperset */ andWhereNotJsonSuperset(column: string, value: any): this; /** * Define a where clause with value that matches for a subset of * JSON */ whereJsonSubset(column: string, value: any): this; /** * Define a or where clause with value that matches for a subset of * JSON */ orWhereJsonSubset(column: string, value: any): this; /** * Define or where clause with value that matches for a subset of * JSON * * @alias whereJsonSubset */ andWhereJsonSubset(column: string, value: any): this; /** * Define a where clause with value that matches for a subset of * JSON */ whereNotJsonSubset(column: string, value: any): this; /** * Define a or where clause with value that matches for a subset of * JSON */ orWhereNotJsonSubset(column: string, value: any): this; /** * Define or where clause with value that matches for a subset of * JSON * * @alias whereNotJsonSubset */ andWhereNotJsonSubset(column: string, value: any): this; /** * Adds a where clause with comparison of a value returned * by a JsonPath given an operator and a value. */ whereJsonPath(column: string, jsonPath: string, operator: any, value?: any): this; /** * Adds a or where clause with comparison of a value returned * by a JsonPath given an operator and a value. */ orWhereJsonPath(column: string, jsonPath: string, operator: any, value?: any): this; /** * Adds a where clause with comparison of a value returned * by a JsonPath given an operator and a value. * * @alias whereJsonPath */ andWhereJsonPath(column: string, jsonPath: string, operator: any, value?: any): this; /** * Add a join clause */ join(table: any, first: any, operator?: any, second?: any): this; /** * Add an inner join clause */ innerJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add a left join clause */ leftJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add a left outer join clause */ leftOuterJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add a right join clause */ rightJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add a right outer join clause */ rightOuterJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add a full outer join clause */ fullOuterJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add a cross join clause */ crossJoin(table: any, first: any, operator?: any, second?: any): this; /** * Add join clause as a raw query */ joinRaw(sql: any, bindings?: any): this; /** * Adds a having clause. The having clause breaks for `postgreSQL` when * referencing alias columns, since PG doesn't support alias columns * being referred within `having` clause. The end user has to * use raw queries in this case. */ having(key: any, operator?: any, value?: any): this; /** * Adds or having clause. The having clause breaks for `postgreSQL` when * referencing alias columns, since PG doesn't support alias columns * being referred within `having` clause. The end user has to * use raw queries in this case. */ orHaving(key: any, operator?: any, value?: any): this; /** * Alias for [[having]] */ andHaving(key: any, operator?: any, value?: any): this; /** * Adding having in clause to the query */ havingIn(key: any, value: any): this; /** * Adding or having in clause to the query */ orHavingIn(key: any, value: any): this; /** * Alias for [[havingIn]] */ andHavingIn(key: any, value: any): this; /** * Adding having not in clause to the query */ havingNotIn(key: any, value: any): this; /** * Adding or having not in clause to the query */ orHavingNotIn(key: any, value: any): this; /** * Alias for [[havingNotIn]] */ andHavingNotIn(key: any, value: any): this; /** * Adding having null clause */ havingNull(key: any): this; /** * Adding or having null clause */ orHavingNull(key: any): this; /** * Alias for [[havingNull]] clause */ andHavingNull(key: any): this; /** * Adding having not null clause */ havingNotNull(key: any): this; /** * Adding or having not null clause */ orHavingNotNull(key: any): this; /** * Alias for [[havingNotNull]] clause */ andHavingNotNull(key: any): this; /** * Adding `having exists` clause */ havingExists(value: any): this; /** * Adding `or having exists` clause */ orHavingExists(value: any): this; /** * Alias for [[havingExists]] */ andHavingExists(value: any): this; /** * Adding `having not exists` clause */ havingNotExists(value: any): this; /** * Adding `or having not exists` clause */ orHavingNotExists(value: any): this; /** * Alias for [[havingNotExists]] */ andHavingNotExists(value: any): this; /** * Adding `having between` clause */ havingBetween(key: any, value: any): this; /** * Adding `or having between` clause */ orHavingBetween(key: any, value: any): this; /** * Alias for [[havingBetween]] */ andHavingBetween(key: any, value: any): this; /** * Adding `having not between` clause */ havingNotBetween(key: any, value: any): this; /** * Adding `or having not between` clause */ orHavingNotBetween(key: any, value: any): this; /** * Alias for [[havingNotBetween]] */ andHavingNotBetween(key: any, value: any): this; /** * Adding a where clause using raw sql */ havingRaw(sql: any, bindings?: any): this; /** * Adding a where clause using raw sql */ orHavingRaw(sql: any, bindings?: any): this; /** * Alias for [[havingRaw]] */ andHavingRaw(sql: any, bindings?: any): this; /** * Add distinct clause */ distinct(...columns: any[]): this; /** * Add distinctOn clause */ distinctOn(...columns: any[]): this; /** * Add group by clause */ groupBy(...columns: any[]): this; /** * Add group by clause as a raw query */ groupByRaw(sql: any, bindings?: any): this; /** * Add order by clause */ orderBy(column: any, direction?: any): this; /** * Add order by clause as a raw query */ orderByRaw(sql: any, bindings?: any): this; /** * Define select offset */ offset(value: number): this; /** * Define results limit */ limit(value: number): this; /** * Define union queries */ union(queries: any, wrap?: boolean): this; /** * Define union all queries */ unionAll(queries: any, wrap?: boolean): this; /** * Define intersect queries */ intersect(queries: any, wrap?: boolean): this; /** * Clear select columns */ clearSelect(): this; /** * Clear where clauses */ clearWhere(): this; /** * Clear order by */ clearOrder(): this; /** * Clear having */ clearHaving(): this; /** * Clear limit */ clearLimit(): this; /** * Clear offset */ clearOffset(): this; /** * Specify `FOR UPDATE` lock mode for a given * query */ forUpdate(...tableNames: string[]): this; /** * Specify `FOR SHARE` lock mode for a given * query */ forShare(...tableNames: string[]): this; /** * Skip locked rows */ skipLocked(): this; /** * Fail when query wants a locked row */ noWait(): this; /** * Define `with` CTE */ with(alias: any, query: any, columns?: string[]): this; /** * Define `with` CTE with recursive keyword */ withRecursive(alias: any, query: any, columns?: string[]): this; /** * Define `with materialized` CTE */ withMaterialized(alias: any, query: any, columns?: string[]): this; /** * Define not `with materialized` CTE */ withNotMaterialized(alias: any, query: any, columns?: string[]): this; /** * Define schema for the table */ withSchema(schema: any): this; /** * Define table alias */ as(alias: any): this; /** * Count rows for the current query */ count(columns: any, alias?: any): this; /** * Count distinct rows for the current query */ countDistinct(columns: any, alias?: any): this; /** * Make use of `min` aggregate function */ min(columns: any, alias?: any): this; /** * Make use of `max` aggregate function */ max(columns: any, alias?: any): this; /** * Make use of `avg` aggregate function */ avg(columns: any, alias?: any): this; /** * Make use of distinct `avg` aggregate function */ avgDistinct(columns: any, alias?: any): this; /** * Make use of `sum` aggregate function */ sum(columns: any, alias?: any): this; /** * Make use of distinct `sum` aggregate function */ sumDistinct(columns: any, alias?: any): this; /** * A shorthand for applying offset and limit based upon * the current page */ forPage(page: number, perPage: number): this; /** * Define a query to constraint to be defined when condition is truthy */ if(condition: any, matchCallback: (query: this) => any, noMatchCallback?: (query: this) => any): this; /** * Define a query to constraint to be defined when condition is falsy */ unless(condition: any, matchCallback: (query: this) => any, noMatchCallback?: (query: this) => any): this; /** * Define matching blocks just like `if/else if and else`. */ match(...blocks: ([condition: any, callback: (query: this) => any] | ((query: this) => any))[]): this; /** * Applies statements and returns knex query */ toKnex(): Knex.QueryBuilder<any, any>; }