ts-prorm-orm 1.1.0

package/dist/decorators/query-options.js

@@ -0,0 +1,556 @@
+"use strict";
+/**
+ * Query options and performance hint decorators for the ORM.
+ *
+ * Provides decorators for controlling query execution:
+ * - Query hints (index hints, force index, ignore index)
+ * - Lock options (row locking, timeout, skip locked)
+ * - Statement timeout
+ * - Idle in transaction timeout
+ * - Cursor-based fetching
+ * - FETCH options (FIRST, OFFSET)
+ * - DISTINCT ON (PostgreSQL)
+ * - TABLESAMPLE
+ *
+ * Usage:
+ *
+ *   // Index hints
+ *   @UseIndex('idx_name')
+ *   @ForceIndex('idx_name')
+ *   @IgnoreIndex('idx_name')
+ *   class User extends Model {}
+ *
+ *   // Lock options (method decorator)
+ *   @WithLock({ mode: 'UPDATE', timeout: 5000, skipLocked: true })
+ *   async processOrder(id: number) { ... }
+ *
+ *   // Statement timeout (method decorator)
+ *   @StatementTimeout(30000)
+ *   async runLongQuery() { ... }
+ *
+ *   // Cursor-based fetch
+ *   @Cursor({ holdable: true })
+ *   async *getAllUsers() { ... }
+ *
+ *   // FETCH options
+ *   @Fetch(100)
+ *   @Distinct
+ *   async *getUsers() { ... }
+ *
+ *   // TABLESAMPLE
+ *   @Tablesample({ method: 'BERNOULLI', percentage: 50 })
+ *   async *getSampleUsers() { ... }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistinctOn = void 0;
+exports.UseIndex = UseIndex;
+exports.ForceIndex = ForceIndex;
+exports.IgnoreIndex = IgnoreIndex;
+exports.Tablesample = Tablesample;
+exports.Distinct = Distinct;
+exports.WithLock = WithLock;
+exports.StatementTimeout = StatementTimeout;
+exports.IdleInTransactionTimeout = IdleInTransactionTimeout;
+exports.Cursor = Cursor;
+exports.Fetch = Fetch;
+exports.FetchWith = FetchWith;
+exports.getQueryHints = getQueryHints;
+exports.getLockOptions = getLockOptions;
+exports.getStatementTimeout = getStatementTimeout;
+exports.getIdleInTransactionTimeout = getIdleInTransactionTimeout;
+exports.getCursorOptions = getCursorOptions;
+exports.getFetchOptions = getFetchOptions;
+exports.getDistinctOnColumns = getDistinctOnColumns;
+exports.getTablesampleOptions = getTablesampleOptions;
+exports.isDistinctEnabled = isDistinctEnabled;
+exports.generateIndexHintSQL = generateIndexHintSQL;
+exports.generateLockSQL = generateLockSQL;
+exports.generateStatementTimeoutSQL = generateStatementTimeoutSQL;
+exports.generateIdleInTransactionTimeoutSQL = generateIdleInTransactionTimeoutSQL;
+exports.generateTablesampleSQL = generateTablesampleSQL;
+exports.generateDistinctOnSQL = generateDistinctOnSQL;
+exports.generateCursorSQL = generateCursorSQL;
+require("reflect-metadata");
+// ==================== Metadata Keys ====================
+const QUERY_HINTS_KEY = Symbol('prorm:queryHints');
+const LOCK_OPTIONS_KEY = Symbol('prorm:lockOptions');
+const STATEMENT_TIMEOUT_KEY = Symbol('prorm:statementTimeout');
+const IDLE_TRANSACTION_TIMEOUT_KEY = Symbol('prorm:idleInTransactionTimeout');
+const CURSOR_OPTIONS_KEY = Symbol('prorm:cursorOptions');
+const FETCH_OPTIONS_KEY = Symbol('prorm:fetchOptions');
+const DISTINCT_ON_KEY = Symbol('prorm:distinctOn');
+const TABLESAMPLE_KEY = Symbol('prorm:tablesample');
+const DISTINCT_KEY = Symbol('prorm:distinct');
+// ==================== Class Decorators ====================
+/**
+ * Decorator to specify USE INDEX hint.
+ * Suggest the optimizer to use a specific index.
+ *
+ * Usage:
+ *
+ *   @UseIndex('idx_user_email')
+ *   @UseIndex(['idx_user_email', 'idx_user_status'])
+ *   class User extends Model {}
+ *
+ * @param index - Index name or array of index names
+ */
+function UseIndex(index) {
+    return function (target) {
+        const indexes = Array.isArray(index) ? index : [index];
+        const existing = Reflect.getMetadata(QUERY_HINTS_KEY, target) || {};
+        existing.useIndex = [...(existing.useIndex || []), ...indexes];
+        Reflect.defineMetadata(QUERY_HINTS_KEY, existing, target);
+    };
+}
+/**
+ * Decorator to specify FORCE INDEX hint.
+ * Force the optimizer to use a specific index.
+ *
+ * Usage:
+ *
+ *   @ForceIndex('idx_user_email')
+ *   class User extends Model {}
+ *
+ * @param index - Index name
+ */
+function ForceIndex(index) {
+    return function (target) {
+        const indexes = Array.isArray(index) ? index : [index];
+        const existing = Reflect.getMetadata(QUERY_HINTS_KEY, target) || {};
+        existing.forceIndex = [...(existing.forceIndex || []), ...indexes];
+        Reflect.defineMetadata(QUERY_HINTS_KEY, existing, target);
+    };
+}
+/**
+ * Decorator to specify IGNORE INDEX hint.
+ * Tell the optimizer to ignore a specific index.
+ *
+ * Usage:
+ *
+ *   @IgnoreIndex('idx_user_email')
+ *   class User extends Model {}
+ *
+ * @param index - Index name
+ */
+function IgnoreIndex(index) {
+    return function (target) {
+        const indexes = Array.isArray(index) ? index : [index];
+        const existing = Reflect.getMetadata(QUERY_HINTS_KEY, target) || {};
+        existing.ignoreIndex = [...(existing.ignoreIndex || []), ...indexes];
+        Reflect.defineMetadata(QUERY_HINTS_KEY, existing, target);
+    };
+}
+/**
+ * Decorator to set tablesample for query.
+ * Sample a subset of rows for query performance.
+ *
+ * Usage:
+ *
+ *   @Tablesample({ method: 'BERNOULLI', percentage: 50 })
+ *   class User extends Model {}
+ *
+ *   @Tablesample({ method: 'SYSTEM', pages: 100 })
+ *   class User extends Model {}
+ *
+ * @param options - Tablesample options
+ */
+function Tablesample(options) {
+    return function (target) {
+        Reflect.defineMetadata(TABLESAMPLE_KEY, options, target);
+    };
+}
+/**
+ * Decorator to enable DISTINCT ON (PostgreSQL).
+ *
+ * Usage:
+ *
+ *   @Distinct
+ *   class User extends Model {}
+ *
+ *   @DistinctOn(['email'])
+ *   class User extends Model {}
+ *
+ * @param columns - Columns for DISTINCT ON (optional)
+ */
+function Distinct(columns) {
+    return function (target) {
+        if (columns?.length) {
+            Reflect.defineMetadata(DISTINCT_ON_KEY, columns, target);
+        }
+        else {
+            Reflect.defineMetadata(DISTINCT_KEY, true, target);
+        }
+    };
+}
+/**
+ * Alias for @Distinct for DISTINCT ON
+ */
+exports.DistinctOn = Distinct;
+// ==================== Method Decorators ====================
+/**
+ * Decorator to apply row lock to a method.
+ * Provides options for locking rows during query execution.
+ *
+ * Usage:
+ *
+ *   @WithLock({ mode: 'UPDATE', timeout: 5000, skipLocked: true })
+ *   async processOrder(id: number) {
+ *     const order = await Order.findByPk(id, { lock: 'UPDATE' });
+ *     // process order
+ *   }
+ *
+ * @param options - Lock options
+ */
+function WithLock(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const lockOptions = {
+            mode: options.mode || 'UPDATE',
+            timeout: options.timeout || 30000,
+            skipLocked: options.skipLocked || false,
+            tables: options.tables,
+        };
+        Reflect.defineMetadata(LOCK_OPTIONS_KEY, lockOptions, target, propertyKey);
+        // Wrap the method to apply lock context
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            // Note: In practice, this would acquire the lock via prorm.transaction
+            // The lock is applied when queries are executed within the method
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+/**
+ * Decorator to set statement timeout.
+ * Abort queries that take longer than the specified timeout.
+ *
+ * Usage:
+ *
+ *   @StatementTimeout(30000)  // 30 seconds
+ *   async runLongQuery() {
+ *     return await this.query('SELECT * FROM large_table');
+ *   }
+ *
+ * @param timeout - Timeout in milliseconds
+ */
+function StatementTimeout(timeout) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata(STATEMENT_TIMEOUT_KEY, { timeout, scope: 'session' }, target, propertyKey);
+        // Wrap the method to set timeout
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            // Note: In practice, this would set the timeout before executing
+            // and reset it after the method completes
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+/**
+ * Decorator to set idle in transaction timeout.
+ * Abort transactions that are idle for longer than the specified timeout.
+ *
+ * Usage:
+ *
+ *   @IdleInTransactionTimeout(60000)  // 1 minute
+ *   async runTransaction() {
+ *     // long running transaction
+ *   }
+ *
+ * @param timeout - Timeout in milliseconds
+ */
+function IdleInTransactionTimeout(timeout) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata(IDLE_TRANSACTION_TIMEOUT_KEY, { timeout, scope: 'session' }, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Decorator to use cursor-based fetching.
+ * Useful for processing large result sets in batches.
+ *
+ * Usage:
+ *
+ *   @Cursor({ holdable: true })
+ *   async *getAllUsers() {
+ *     for await (const user of this.findAll({ cursor: true })) {
+ *       yield user;
+ *     }
+ *   }
+ *
+ * @param options - Cursor options
+ */
+function Cursor(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const cursorOptions = {
+            holdable: options.holdable || 'WITHOUT HOLD',
+            name: options.name,
+            scroll: options.scroll ?? true,
+        };
+        Reflect.defineMetadata(CURSOR_OPTIONS_KEY, cursorOptions, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Decorator to set FETCH FIRST limit.
+ * Limits the number of rows returned by a query.
+ *
+ * Usage:
+ *
+ *   @Fetch(100)
+ *   async *getTopUsers() {
+ *     return await User.findAll({ limit: 100 });
+ *   }
+ *
+ * @param limit - Number of rows to fetch
+ */
+function Fetch(limit) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata(FETCH_OPTIONS_KEY, { limit, offset: 0 }, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Decorator to set FETCH with offset.
+ * Useful for pagination.
+ *
+ * Usage:
+ *
+ *   @Fetch({ first: 100, offset: 50 })
+ *   async *getPageUsers() {
+ *     return await User.findAll({ offset: 50, limit: 100 });
+ *   }
+ *
+ * @param options - Fetch options with limit and optional offset
+ */
+function FetchWith(options) {
+    return function (target, propertyKey, descriptor) {
+        Reflect.defineMetadata(FETCH_OPTIONS_KEY, { limit: options.first, offset: options.offset || 0 }, target, propertyKey);
+        return descriptor;
+    };
+}
+// ==================== Helper Functions ====================
+/**
+ * Get query hints for a model.
+ *
+ * @param target - The target class or prototype
+ * @returns Query hints or undefined
+ */
+function getQueryHints(target) {
+    return Reflect.getMetadata(QUERY_HINTS_KEY, target);
+}
+/**
+ * Get lock options for a method.
+ *
+ * @param target - The target object
+ * @param propertyKey - The property key
+ * @returns Lock options or undefined
+ */
+function getLockOptions(target, propertyKey) {
+    return Reflect.getMetadata(LOCK_OPTIONS_KEY, target, propertyKey);
+}
+/**
+ * Get statement timeout for a method.
+ *
+ * @param target - The target object
+ * @param propertyKey - The property key
+ * @returns Statement timeout options or undefined
+ */
+function getStatementTimeout(target, propertyKey) {
+    return Reflect.getMetadata(STATEMENT_TIMEOUT_KEY, target, propertyKey);
+}
+/**
+ * Get idle transaction timeout for a method.
+ *
+ * @param target - The target object
+ * @param propertyKey - The property key
+ * @returns Idle transaction timeout options or undefined
+ */
+function getIdleInTransactionTimeout(target, propertyKey) {
+    return Reflect.getMetadata(IDLE_TRANSACTION_TIMEOUT_KEY, target, propertyKey);
+}
+/**
+ * Get cursor options for a method.
+ *
+ * @param target - The target object
+ * @param propertyKey - The property key
+ * @returns Cursor options or undefined
+ */
+function getCursorOptions(target, propertyKey) {
+    return Reflect.getMetadata(CURSOR_OPTIONS_KEY, target, propertyKey);
+}
+/**
+ * Get FETCH options for a method.
+ *
+ * @param target - The target object
+ * @param propertyKey - The property key
+ * @returns FETCH options or undefined
+ */
+function getFetchOptions(target, propertyKey) {
+    return Reflect.getMetadata(FETCH_OPTIONS_KEY, target, propertyKey);
+}
+/**
+ * Get DISTINCT ON columns for a model.
+ *
+ * @param target - The target class or prototype
+ * @returns DISTINCT ON columns or undefined
+ */
+function getDistinctOnColumns(target) {
+    return Reflect.getMetadata(DISTINCT_ON_KEY, target);
+}
+/**
+ * Get tablesample options for a model.
+ *
+ * @param target - The target class or prototype
+ * @returns Tablesample options or undefined
+ */
+function getTablesampleOptions(target) {
+    return Reflect.getMetadata(TABLESAMPLE_KEY, target);
+}
+/**
+ * Check if DISTINCT is enabled for a model.
+ *
+ * @param target - The target class or prototype
+ * @returns True if DISTINCT is enabled
+ */
+function isDistinctEnabled(target) {
+    return Reflect.getMetadata(DISTINCT_KEY, target) === true;
+}
+/**
+ * Generate index hint SQL.
+ *
+ * @param hints - Query hints
+ * @param dialect - Database dialect
+ * @returns SQL string or undefined
+ */
+function generateIndexHintSQL(hints, dialect) {
+    const parts = [];
+    if (dialect === 'mysql' || dialect === 'mariadb') {
+        if (hints.useIndex?.length) {
+            parts.push(`USE INDEX (${hints.useIndex.join(', ')})`);
+        }
+        if (hints.forceIndex?.length) {
+            parts.push(`FORCE INDEX (${hints.forceIndex.join(', ')})`);
+        }
+        if (hints.ignoreIndex?.length) {
+            parts.push(`IGNORE INDEX (${hints.ignoreIndex.join(', ')})`);
+        }
+    }
+    if (dialect === 'sqlserver') {
+        if (hints.useIndex?.length) {
+            parts.push(`WITH (INDEX(${hints.useIndex.join(', ')}))`);
+        }
+    }
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+/**
+ * Generate lock SQL.
+ *
+ * @param options - Lock options
+ * @returns SQL FOR clause or undefined
+ */
+function generateLockSQL(options) {
+    if (options.mode === 'UPDATE') {
+        return 'FOR UPDATE' + (options.skipLocked ? ' SKIP LOCKED' : '');
+    }
+    if (options.mode === 'SHARE') {
+        return 'FOR SHARE' + (options.skipLocked ? ' SKIP LOCKED' : '');
+    }
+    if (options.mode === 'UPDATE NOWAIT') {
+        return 'FOR UPDATE NOWAIT';
+    }
+    if (options.mode === 'SHARE NOWAIT') {
+        return 'FOR SHARE NOWAIT';
+    }
+    if (options.mode === 'UPDATE SKIP LOCKED') {
+        return 'FOR UPDATE SKIP LOCKED';
+    }
+    return undefined;
+}
+/**
+ * Generate statement timeout SQL.
+ *
+ * @param timeout - Timeout in milliseconds
+ * @param scope - Session or global
+ * @returns SQL string
+ */
+function generateStatementTimeoutSQL(timeout, scope = 'session') {
+    if (timeout <= 0) {
+        return `SET ${scope} statement_timeout = 0`;
+    }
+    return `SET ${scope} statement_timeout = '${timeout}ms'`;
+}
+/**
+ * Generate idle in transaction timeout SQL.
+ *
+ * @param timeout - Timeout in milliseconds
+ * @param scope - Session or global
+ * @returns SQL string
+ */
+function generateIdleInTransactionTimeoutSQL(timeout, scope = 'session') {
+    return `SET ${scope} idle_in_transaction_session_timeout = '${timeout}ms'`;
+}
+/**
+ * Generate tablesample SQL.
+ *
+ * @param options - Tablesample options
+ * @returns SQL TABLESAMPLE clause
+ */
+function generateTablesampleSQL(options) {
+    const { method, percentage, pages, seed, repeatable } = options;
+    if (method === 'BERNOULLI') {
+        let sql = `TABLESAMPLE BERNOULLI(${percentage || 10})`;
+        if (repeatable !== undefined) {
+            sql += ` REPEATABLE(${repeatable})`;
+        }
+        else if (seed !== undefined) {
+            sql += ` REPEATABLE(${seed})`;
+        }
+        return sql;
+    }
+    if (method === 'SYSTEM') {
+        if (pages) {
+            let sql = `TABLESAMPLE SYSTEM(${pages})`;
+            if (repeatable !== undefined) {
+                sql += ` REPEATABLE(${repeatable})`;
+            }
+            return sql;
+        }
+        let sql = `TABLESAMPLE SYSTEM(${percentage || 10})`;
+        if (repeatable !== undefined) {
+            sql += ` REPEATABLE(${repeatable})`;
+        }
+        return sql;
+    }
+    if (method === 'SYSTEM_TIME') {
+        const timestamp = options.timestamp
+            ? typeof options.timestamp === 'string'
+                ? `'${options.timestamp}'`
+                : `'${options.timestamp.toISOString()}'`
+            : "timestamp 'now'";
+        return `TABLESAMPLE SYSTEM_TIME(${timestamp})`;
+    }
+    return '';
+}
+/**
+ * Generate DISTINCT ON SQL (PostgreSQL).
+ *
+ * @param columns - DISTINCT ON columns
+ * @returns SQL DISTINCT ON clause
+ */
+function generateDistinctOnSQL(columns) {
+    return `DISTINCT ON (${columns.join(', ')})`;
+}
+/**
+ * Generate cursor SQL.
+ *
+ * @param options - Cursor options
+ * @param name - Cursor name (optional)
+ * @returns SQL DECLARE CURSOR statement
+ */
+function generateCursorSQL(options, name) {
+    const cursorName = name || options.name || 'cursor';
+    const hold = options.holdable === 'HOLD' ? 'WITH HOLD' : 'WITHOUT HOLD';
+    const scroll = options.scroll !== false ? 'SCROLL' : 'NO SCROLL';
+    return `DECLARE ${cursorName} CURSOR ${scroll} ${hold} FOR`;
+}

package/dist/decorators/range.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Range Decorator for the ORM
+ *
+ * Provides PostgreSQL Range Types support.
+ * Range types: int4range, int8range, numrange, tsrange, tstzrange, daterange
+ *
+ * Usage:
+ *
+ *   // Timestamp range
+ *   @Range('tsrange')
+ *   duration: [Date, Date];
+ *
+ *   // Integer range
+ *   @Range('int4range')
+ *   quantity: [number, number];
+ *
+ *   // Date range
+ *   @Range('daterange')
+ *   dates: [string, string];
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Range = Range;
+exports.getRangeMetadata = getRangeMetadata;
+exports.getAllRangeMetadata = getAllRangeMetadata;
+exports.isRangeColumn = isRangeColumn;
+exports.clearRangeMetadata = clearRangeMetadata;
+exports.buildRangeLiteral = buildRangeLiteral;
+exports.getRangeContainedBySQL = getRangeContainedBySQL;
+exports.getRangeOverlapSQL = getRangeOverlapSQL;
+// ==================== Registry ====================
+const rangeMetadataMap = new Map();
+/**
+ * Range decorator for PostgreSQL Range columns
+ *
+ * @param options - Required range options (subtype is required)
+ *
+ * @example
+ * // Timestamp range
+ * class Reservation extends Model {
+ *   @Range({ subtype: 'tsrange' })
+ *   during: [Date, Date];
+ * }
+ *
+ * // Date range
+ * class Event extends Model {
+ *   @Range({ subtype: 'daterange' })
+ *   dates: [string, string];
+ * }
+ *
+ * // Integer range
+ * class Inventory extends Model {
+ *   @Range({ subtype: 'int4range', allowNull: false })
+ *   quantity: [number, number];
+ * }
+ */
+function Range(options) {
+    return function (target, propertyKey) {
+        const decoratorOptions = {
+            ...options,
+            subtype: 'int4range',
+            allowNull: true,
+        };
+        // Validate subtype
+        const validSubtypes = [
+            'int4range',
+            'int8range',
+            'numrange',
+            'tsrange',
+            'tstzrange',
+            'daterange',
+        ];
+        if (!validSubtypes.includes(decoratorOptions.subtype)) {
+            throw new Error(`Invalid range subtype: ${decoratorOptions.subtype}. Valid subtypes: ${validSubtypes.join(', ')}`);
+        }
+        // Get or create metadata map for this class
+        if (!rangeMetadataMap.has(target.constructor)) {
+            rangeMetadataMap.set(target.constructor, new Map());
+        }
+        const metadataMap = rangeMetadataMap.get(target.constructor);
+        // Store metadata
+        metadataMap.set(propertyKey, {
+            options: decoratorOptions,
+        });
+    };
+}
+/**
+ * Get Range metadata for a property
+ *
+ * @param target - The target class
+ * @param propertyKey - The property name
+ * @returns Range metadata or undefined if not found
+ */
+function getRangeMetadata(target, propertyKey) {
+    const metadataMap = rangeMetadataMap.get(target.constructor);
+    if (!metadataMap) {
+        return undefined;
+    }
+    return metadataMap.get(propertyKey);
+}
+/**
+ * Get all Range metadata for a class
+ *
+ * @param target - The target class
+ * @returns Map of property names to Range metadata
+ */
+function getAllRangeMetadata(target) {
+    return rangeMetadataMap.get(target.constructor) || new Map();
+}
+/**
+ * Check if a property is a Range column
+ *
+ * @param target - The target class
+ * @param propertyKey - The property name
+ * @returns True if the property is a Range column
+ */
+function isRangeColumn(target, propertyKey) {
+    const metadata = getRangeMetadata(target, propertyKey);
+    return metadata !== undefined;
+}
+/**
+ * Clear Range metadata (useful for testing)
+ */
+function clearRangeMetadata() {
+    rangeMetadataMap.clear();
+}
+/**
+ * Build the SQL for a range literal
+ *
+ * @param lower - Lower bound of the range
+ * @param upper - Upper bound of the range
+ * @param options - Options for the range
+ * @returns SQL for the range literal
+ */
+function buildRangeLiteral(lower, upper, options) {
+    const lowerBracket = options?.inclusiveLower !== false ? '[' : '(';
+    const upperBracket = options?.inclusiveUpper !== false ? ']' : ')';
+    const formatBound = (bound) => {
+        if (bound === null || bound === undefined) {
+            return '';
+        }
+        if (typeof bound === 'string') {
+            return `'${bound}'`;
+        }
+        if (bound instanceof Date) {
+            return `'${bound.toISOString()}'`;
+        }
+        return String(bound);
+    };
+    return `${lowerBracket}${formatBound(lower)}, ${formatBound(upper)}${upperBracket}::${'tsrange'}`;
+}
+/**
+ * Get the SQL operator for range containment
+ *
+ * @returns SQL for the @> operator
+ */
+function getRangeContainedBySQL() {
+    return '<@';
+}
+/**
+ * Get the SQL operator for range overlap
+ *
+ * @returns SQL for the && operator
+ */
+function getRangeOverlapSQL() {
+    return '&&';
+}