ottoman/lib/types/query/query.d.ts

Ottoman Couchbase ODM

import { BaseQuery } from './base-query';
import { IConditionExpr, IGroupBy, IIndexOnParams, IIndexWithParams, IndexType, ISelectType, LetExprType, LogicalWhereExpr, QueryBuildOptionsType, SortType } from './interface/query.types';
import { QueryOptions, QueryResult } from 'couchbase';
export declare class Query extends BaseQuery {
    /**
     * SELECT Expression.
     */
    private selectExpr?;
    /**
     * WHERE Expression.
     */
    private whereExpr?;
    /**
     * ORDER BY Expression.
     */
    private orderExpr?;
    /**
     * LIMIT Expression.
     */
    private limitExpr?;
    /**
     * OFFSET Expression.
     */
    private offSetExpr?;
    /**
     * LET Expression.
     */
    private letExpr?;
    /**
     * GROUP BY Expression.
     */
    private groupByExpr?;
    /**
     * LETTING Expression.
     */
    private lettingExpr?;
    /**
     * HAVING Expression.
     */
    private havingExpr?;
    /**
     * Plain JOIN Expression.
     */
    private plainJoinExpr?;
    /**
     * USE Expression.
     */
    private useKeysExpr?;
    /**
     * Available query types.
     */
    private queryType?;
    /**
     * INDEX ON Expression.
     */
    private indexOn?;
    /**
     * Types of supported Index statements.
     */
    private indexType?;
    /**
     * Index name.
     */
    private indexName?;
    /**
     * INDEX USING GSI Expression.
     */
    private indexUsingGSI?;
    /**
     * INDEX WITH Expression.
     */
    private indexWith?;
    /**
     * @summary Create an instance of Query.
     * @name Query
     * @class
     * @public
     *
     * @param conditions List of SELECT clause conditions
     * @param collection Collection name
     * @returns Query
     *
     * @example
     * ```ts
     * const query = new Query({
     *  $select: [{ $field: 'address' }],
     *  $where: {
     *    $nill: [
     *      { address: { $like: '%57-59%' } },
     *      { free_breakfast: true },
     *      { free_lunch: [1] }
     *    ]
     *   }
     *  },
     *  'travel-sample');
     * ```
     */
    constructor(conditions: IConditionExpr, collection: string);
    /**
     * Add result selectors to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }]).build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * ```
     */
    select(value?: ISelectType[] | string | undefined): Query;
    /**
     * Add index type and name to INDEX clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const result = new Query({}, 'travel-sample')
     *  .index('DROP', 'travel_sample_id_test')
     *  .build();
     * console.log(result)
     * ```
     * ```sql
     * DROP INDEX `travel-sample`.`travel_sample_id_test`
     * ```
     */
    index(type: IndexType, name: string): Query;
    /**
     * Add items to ON clause in INDEX clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const on = [{ name: 'travel-sample.callsing', sort: 'ASC' }];
     * const result = new Query({}, 'travel-sample')
     *    .index('CREATE', 'travel_sample_id_test')
     *    .on(on)
     *    .build();
     * console.log(result)
     * ```
     * ```sql
     * CREATE INDEX `travel_sample_id_test` ON `travel-sample` (`travel-sample.callsing`['ASC'])
     * ```
     **/
    on(value: IIndexOnParams[]): Query;
    /**
     * Create INDEX using General Secondary Index (GSI).
     * @method
     * @public
     *
     * @example
     * ```ts
     * const result = new Query({}, 'travel-sample')
     *    .index('CREATE', 'travel_sample_id_test')
     *    .usingGSI()
     *    .build();
     * console.log(result)
     * ```
     * ```sql
     * CREATE INDEX `travel_sample_id_test` USING GSI
     * ```
     **/
    usingGSI(): Query;
    /**
     * Add items to WITH clause in INDEX clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const withExpr = { nodes: ['192.168.1.1:8078'], defer_build: true, num_replica: 2 };
     * const result = new Query({}, 'travel-sample')
     *    .index('CREATE', 'travel_sample_id_test')
     *    .with(withExpr)
     *    .build();
     * console.log(result)
     * ```
     * ```sql
     * CREATE INDEX `travel_sample_id_test`
     * WITH {'nodes': ['192.168.1.1:8078'],'defer_build': true,'num_replica': 2}
     * ```
     **/
    with(value: IIndexWithParams): Query;
    /**
     * Add WHERE expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const expr_where = {
     *   $or: [
     *     { address: { $like: '%57-59%' } },
     *     { free_breakfast: true },
     *     { name: { $eq: 'John', $ignoreCase: true } }
     *   ]
     * };
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .where(expr_where)
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * WHERE (address LIKE "%57-59%" OR free_breakfast = true OR (LOWER(name) = LOWER("John")))
     * ```
     **/
    where(value: LogicalWhereExpr): Query;
    /**
     * Add JOIN expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```tS
     * const query = new Query({}, 'beer-sample brewery');
     * const result = query.select([{ $field: 'address' }])
     *    .plainJoin(
     *        'JOIN `beer-sample` beer ON beer.brewery_id = LOWER(REPLACE(brewery.name, " ", "_"))'
     *     )
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT beer.name
     * FROM `beer-sample` brewery
     * JOIN `beer-sample` beer ON beer.brewery_id = LOWER(REPLACE(brewery.name, " ", "_"))
     * ```
     */
    plainJoin(value: string): Query;
    /**
     * Add ORDER BY expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .orderBy({ size: 'DESC' })
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * ORDER BY size = 'DESC'
     * ```
     */
    orderBy(value: Record<string, SortType>): Query;
    /**
     * Add LIMIT expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .limit(10)
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * LIMIT 10
     * ```
     **/
    limit(value: number): Query;
    /**
     * Add OFFSET expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .offset(10)
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * OFFSET 10
     * ```
     **/
    offset(value: number): Query;
    /**
     * Add LET expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     *
     * ```ts
     * // SELECT expression definition
     * const selectExpr = 't1.airportname, t1.geo.lat, t1.geo.lon, t1.city, t1.type';
     *
     * // LET expression definition
     * const letExpr: LetExprType = {
     *   min_lat: 71,
     *   max_lat: 'ABS(t1.geo.lon)*4+1',
     *   place: '(SELECT RAW t2.country FROM `travel-sample` t2 WHERE t2.type = "landmark")',
     * };
     *
     * // WHERE expression definition
     * const whereExpr: LogicalWhereExpr = {
     *   $and: [
     *     { 't1.type': 'airport' },
     *     { 't1.geo.lat': { $gt: { $field: 'min_lat' } } },
     *     { 't1.geo.lat': { $lt: { $field: 'max_lat' } } },
     *     { 't1.country': { $in: { $field: 'place' } } },
     *   ],
     * };
     *
     * // QUERY creation
     * const query = new Query({}, 'travel-sample t1')
     *  .select(selectExpr)
     *  .let(letExpr)
     *  .where(whereExpr)
     *  .build();
     *
     * console.log(query);
     *
     * // QUERY output
     * ```
     * ```sql
     * SELECT t1.airportname,
     *        t1.geo.lat,
     *        t1.geo.lon,
     *        t1.city,
     *        t1.type
     * FROM `travel-sample` t1
     * LET min_lat=71,
     *     max_lat=ABS(t1.geo.lon)*4+1,
     *     place=(
     *         SELECT RAW t2.country
     *         FROM `travel-sample` t2
     *         WHERE t2.type = "landmark")
     * WHERE (t1.type="airport"
     *         AND t1.geo.lat>min_lat
     *         AND t1.geo.lat<max_lat
     *         AND t1.country IN place);
     * ```
     *
     * ```ts
     * // OTTOMAN initialization
     * const ottoman = getDefaultInstance();
     * await startInTest(ottoman);
     *
     * // QUERY execution
     * const { rows } = await ottoman.query(query);
     *
     * // RESULTS
     * console.log(rows)
     * ```
     * ```sh
     * [
     *   {
     *     airportname: 'Wiley Post Will Rogers Mem',
     *     city: 'Barrow',
     *     lat: 71.285446,
     *     lon: -156.766003,
     *     type: 'airport',
     *   },
     *   {
     *     airportname: 'Dillant Hopkins Airport',
     *     city: 'Keene',
     *     lat: 72.270833,
     *     lon: 42.898333,
     *     type: 'airport',
     *   },
     * ]
     * ```
     */
    let(value: LetExprType): Query;
    /**
     * Add GROUP BY expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const groupByExpr = [{ expr: 'COUNT(amount_val)', as: 'amount' }];
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .groupBy(groupByExpr)
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * GROUP BY COUNT(amount) AS amount
     * ```
     */
    groupBy(value: IGroupBy[]): Query;
    /**
     * Add LETTING expression to GROUP BY clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const groupByExpr = [{ expr: 'COUNT(amount_val)', as: 'amount' }];
     * const letExpr = { amount_val: 10 };
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .groupBy(groupByExpr)
     *    .let(letExpr)
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * GROUP BY COUNT(amount) AS amount LETTING amount = 10
     * ```
     */
    letting(value: LetExprType): Query;
    /**
     * Add HAVING expression to GROUP BY clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const groupByExpr = [{ expr: 'COUNT(amount_val)', as: 'amount' }];
     * const having = { address: { $like: '%58%' } };
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .groupBy(groupByExpr)
     *    .having(having)
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * GROUP BY COUNT(amount) AS amount
     * HAVING address LIKE '%58%'
     * ```
     */
    having(value: LogicalWhereExpr): Query;
    /**
     * Add USE KEYS expression to SELECT clause.
     * @method
     * @public
     *
     * @example
     * ```ts
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .useKeys(['airlineR_8093'])
     *    .build()
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample` USE KEYS ['airlineR_8093']
     * ```
     */
    useKeys(value: string[]): Query;
    /**
     * Converts the conditional parameters passed to the constructor to the properties of the N1QL Query.
     * @method
     * @public
     *
     */
    compileFromConditions(conditionals: IConditionExpr): void;
    /**
     * Build a N1QL query from the defined parameters.
     *
     * Can also use `ignoreCase` as part of the `build` method, this will always prioritize the `$ignoreCase` value defined in clause.
     * @example
     * ```ts
     * const expr_where = {
     *   $or: [
     *     { address: { $like: '%57-59%', $ignoreCase: false } }, // ignoreCase will not be applied
     *     { free_breakfast: true },
     *     { name: 'John' } //  ignoreCase will be applied
     *   ],
     * };
     * const query = new Query({}, 'travel-sample');
     * const result = query.select([{ $field: 'address' }])
     *    .where(expr_where)
     *    .build({ ignoreCase: true }); // ignore case is enabled for where clause elements
     * console.log(result)
     * ```
     * ```sql
     * SELECT address
     * FROM `travel-sample`
     * WHERE (address LIKE "%57-59%" OR free_breakfast = true OR `(LOWER(name) = LOWER("John"))`)
     * ```
     *
     * @method
     * @public
     *
     */
    build(options?: QueryBuildOptionsType): string;
    execute<Result = any>(options?: QueryBuildOptionsType, queryOptions?: QueryOptions, ottomanInstance?: import("../ottoman/ottoman").Ottoman): Promise<QueryResult<Result>> | Promise<Result>;
    get conditions(): IConditionExpr;
    set conditions(value: IConditionExpr);
    get collection(): string;
    set collection(value: string);
}