drizzle-cube 0.6.1 → 0.6.3

package/dist/cjs/client/hooks/drillNavigation.d.ts

@@ -0,0 +1,25 @@
+import { DrillOption, DrillPathEntry } from '../types/drill.js';
+import { ChartAxisConfig, CubeQuery } from '../types.js';
+/**
+ * Find an existing drill-path level for the given option and compute the
+ * "navigate back" descriptor (the truncated path + the query/chartConfig to
+ * restore). Returns null when there is no matching existing level.
+ *
+ * Used for both time-granularity drilling (matched by `granularity`) and
+ * hierarchy-dimension drilling (matched by `dimension`).
+ */
+export declare function findNavigateBackToExistingLevel(drillPath: DrillPathEntry[], matches: (entry: DrillPathEntry) => boolean): {
+    newPath: DrillPathEntry[];
+    query: CubeQuery;
+    chartConfig: ChartAxisConfig | null;
+} | null;
+/**
+ * Whether selecting this option means returning all the way to the root via the
+ * original time granularity.
+ */
+export declare function isDrillBackToRootGranularity(option: DrillOption, originalGranularity: string | null): boolean;
+/**
+ * Compute the granularity to remember as the "original" when first drilling via
+ * a time-granularity option. Returns null when nothing should be stored.
+ */
+export declare function computeOriginalGranularity(option: DrillOption, query: CubeQuery): string | null;

package/dist/cjs/client/hooks/queries/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TanStack Query Hooks - Barrel Export
+ *
+ * These hooks provide TanStack Query-based data fetching for:
+ * - Cube metadata (useCubeMetaQuery)
+ * - Single cube data loading (useCubeLoadQuery)
+ * - Multi-cube data loading (useMultiCubeLoadQuery)
+ * - Dry-run/debug data (useDryRunQuery, useMultiDryRunQueries)
+ *
+ * All hooks include built-in debouncing, caching, and error handling.
+ */
+export { useCubeMetaQuery, prefetchCubeMeta, CUBE_META_QUERY_KEY, type UseCubeMetaQueryOptions, type UseCubeMetaQueryResult, } from './useCubeMetaQuery.js';
+export { useCubeLoadQuery, useCubeLoadQuery as useCubeQuery, createQueryKey, type UseCubeLoadQueryOptions, type UseCubeLoadQueryResult, } from './useCubeLoadQuery.js';
+export { useMultiCubeLoadQuery, createMultiQueryKey, type UseMultiCubeLoadQueryOptions, type UseMultiCubeLoadQueryResult, } from './useMultiCubeLoadQuery.js';
+export { useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, useFunnelDryRunQuery, useFlowDryRunQuery, useRetentionDryRunQuery, createDryRunQueryKey, type DebugDataEntry, type FunnelDebugDataEntry, type FlowDebugDataEntry, type RetentionDebugDataEntry, type UseDryRunQueryOptions, type UseDryRunQueryResult, type UseMultiDryRunQueriesOptions, type UseMultiDryRunQueriesResult, } from './useDryRunQuery.js';
+export { useFunnelQuery, createFunnelQueryKey, } from './useFunnelQuery.js';
+export { useFlowQuery, createFlowQueryKey, type UseFlowQueryOptions, type UseFlowQueryResult, } from './useFlowQuery.js';
+export { useRetentionQuery, type UseRetentionQueryOptions, type UseRetentionQueryResult, } from './useRetentionQuery.js';
+export { useExplainQuery, createExplainQueryKey, type UseExplainQueryOptions, type UseExplainQueryResult, } from './useExplainQuery.js';
+export { useExplainAI, type UseExplainAIOptions, type UseExplainAIResult, } from './useExplainAI.js';

package/dist/cjs/client/hooks/queries/useCubeLoadQuery.d.ts

@@ -0,0 +1,85 @@
+import { CubeQuery, CubeResultSet } from '../../types.js';
+import { QueryWarning } from '../../shared/types.js';
+/**
+ * Create a stable query key from a CubeQuery
+ * The key includes all query parameters to ensure proper caching
+ */
+export declare function createQueryKey(query: CubeQuery | null): readonly unknown[];
+export interface UseCubeLoadQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+    /**
+     * Whether to reset result set when query changes
+     * @default true
+     */
+    resetResultSetOnChange?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 60 * 1000 (1 minute)
+     */
+    staleTime?: number;
+    /**
+     * Whether to keep previous data while loading new data
+     * @default true
+     */
+    keepPreviousData?: boolean;
+}
+/** Options for the refetch function */
+export interface RefetchOptions {
+    /** If true, bypasses both client and server caches */
+    bustCache?: boolean;
+}
+export interface UseCubeLoadQueryResult {
+    /** The result set from the query */
+    resultSet: CubeResultSet | null;
+    /** Raw data from the result set */
+    rawData: unknown[] | null;
+    /** Whether the query is loading (initial load) */
+    isLoading: boolean;
+    /** Whether the query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether query is debouncing (waiting for user to stop typing) */
+    isDebouncing: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** The debounced query that was executed */
+    debouncedQuery: CubeQuery | null;
+    /** Whether the current query is valid */
+    isValidQuery: boolean;
+    /** Manually refetch the data. Pass { bustCache: true } to bypass caches. */
+    refetch: (options?: RefetchOptions) => void;
+    /** Clear the query cache */
+    clearCache: () => void;
+    /**
+     * Whether the query needs to be refreshed (manual refresh mode only).
+     * True when the current query config differs from the last executed query.
+     */
+    needsRefresh: boolean;
+    /**
+     * Execute the current query (manual refresh mode only).
+     * In auto-refresh mode, this is the same as refetch().
+     */
+    executeQuery: (options?: RefetchOptions) => void;
+    /** Warnings from query planning (e.g., fan-out without dimensions) */
+    warnings: QueryWarning[] | undefined;
+}
+/**
+ * TanStack Query hook for loading cube data with debouncing
+ *
+ * Usage:
+ * ```tsx
+ * const { resultSet, rawData, isLoading, error } = useCubeLoadQuery(query, {
+ *   debounceMs: 300,
+ *   skip: !isReady
+ * })
+ * ```
+ */
+export declare function useCubeLoadQuery(query: CubeQuery | null, options?: UseCubeLoadQueryOptions): UseCubeLoadQueryResult;

package/dist/cjs/client/hooks/queries/useCubeMetaQuery.d.ts

@@ -0,0 +1,51 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useCubeApi } from '../../providers/CubeApiProvider.js';
+import { CubeMeta, FieldLabelMap } from '../../types.js';
+export declare const CUBE_META_QUERY_KEY: readonly ["cube", "meta"];
+export interface UseCubeMetaQueryOptions {
+    /**
+     * Whether to skip the query (useful for conditional fetching)
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Stale time in milliseconds (how long before data is considered stale)
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseCubeMetaQueryResult {
+    /** Cube metadata */
+    meta: CubeMeta | null;
+    /** Field label map for quick lookups */
+    labelMap: FieldLabelMap;
+    /** Whether the query is loading */
+    isLoading: boolean;
+    /** Whether the query is fetching (includes background refetch) */
+    isFetching: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** Manually refetch the metadata */
+    refetch: () => void;
+    /** Get a field's display label */
+    getFieldLabel: (fieldName: string) => string;
+}
+/**
+ * TanStack Query hook for fetching cube metadata
+ *
+ * Usage:
+ * ```tsx
+ * const { meta, labelMap, isLoading, error, refetch } = useCubeMetaQuery()
+ * ```
+ */
+export declare function useCubeMetaQuery(options?: UseCubeMetaQueryOptions): UseCubeMetaQueryResult;
+/**
+ * Prefetch cube metadata - useful for eager loading
+ *
+ * Usage:
+ * ```tsx
+ * const queryClient = useQueryClient()
+ * await prefetchCubeMeta(queryClient, cubeApi)
+ * ```
+ */
+export declare function prefetchCubeMeta(queryClient: ReturnType<typeof useQueryClient>, cubeApi: ReturnType<typeof useCubeApi>['cubeApi']): Promise<void>;

package/dist/cjs/client/hooks/queries/useDryRunQuery.d.ts

@@ -0,0 +1,153 @@
+import { CubeQuery } from '../../types.js';
+import { QueryAnalysis } from '../../components/AnalysisBuilder/types.js';
+export type DryRunMode = 'regular' | 'comparison' | 'funnel' | 'flow' | 'retention';
+/**
+ * Debug data entry for a single query
+ */
+export interface DebugDataEntry {
+    /** Generated SQL and parameters */
+    sql: {
+        sql: string;
+        params: unknown[];
+    } | null;
+    /** Query analysis (dimensions, measures, complexity, etc.) */
+    analysis: QueryAnalysis | null;
+    /** Server-reported dry-run mode */
+    mode?: DryRunMode | null;
+    /** Query type label from server */
+    queryType?: string | null;
+    /** Join strategy label from server */
+    joinType?: string | null;
+    /** Referenced cubes from server */
+    cubesUsed?: string[];
+    /** Mode-specific metadata (replaces funnel/flow/retention split) */
+    modeMetadata?: unknown;
+    /** Whether this entry is loading */
+    loading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+}
+/**
+ * Create a stable query key for dry-run
+ */
+export declare function createDryRunQueryKey(query: CubeQuery | null): readonly unknown[];
+export interface UseDryRunQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseDryRunQueryResult {
+    /** Debug data for the query */
+    debugData: DebugDataEntry;
+    /** Manually refetch */
+    refetch: () => void;
+}
+/**
+ * TanStack Query hook for single query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useDryRunQuery(query, { skip: !isValidQuery })
+ * ```
+ */
+export declare function useDryRunQuery(query: CubeQuery | null, options?: UseDryRunQueryOptions): UseDryRunQueryResult;
+export interface UseMultiDryRunQueriesOptions {
+    /**
+     * Whether to skip all queries
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseMultiDryRunQueriesResult {
+    /** Debug data for each query */
+    debugDataPerQuery: DebugDataEntry[];
+    /** Whether any query is loading */
+    isLoading: boolean;
+    /** Manually refetch all */
+    refetchAll: () => void;
+}
+/**
+ * TanStack Query hook for multiple query dry-runs (debug) data
+ *
+ * Fetches debug data for multiple queries in parallel.
+ *
+ * Usage:
+ * ```tsx
+ * const { debugDataPerQuery, isLoading } = useMultiDryRunQueries(queries, {
+ *   skip: !isMultiQueryMode
+ * })
+ * ```
+ */
+export declare function useMultiDryRunQueries(queries: CubeQuery[], options?: UseMultiDryRunQueriesOptions): UseMultiDryRunQueriesResult;
+/**
+ * Combined hook for single or multi-query dry-run based on mode
+ *
+ * This is a convenience wrapper that automatically chooses between
+ * single and multi-query dry-run based on the number of queries.
+ *
+ * Usage:
+ * ```tsx
+ * const { debugDataPerQuery } = useDryRunQueries({
+ *   queries: isMultiQueryMode ? allQueries : [currentQuery],
+ *   isMultiQueryMode,
+ *   skip: !isValidQuery
+ * })
+ * ```
+ */
+export declare function useDryRunQueries(options: {
+    queries: CubeQuery[];
+    isMultiQueryMode: boolean;
+    skip?: boolean;
+    staleTime?: number;
+}): UseMultiDryRunQueriesResult;
+export type FunnelDebugDataEntry = DebugDataEntry;
+/**
+ * TanStack Query hook for funnel query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useFunnelDryRunQuery(serverQuery, { skip: !isFunnelMode })
+ * ```
+ */
+export declare function useFunnelDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: FunnelDebugDataEntry;
+    refetch: () => void;
+};
+export type FlowDebugDataEntry = DebugDataEntry;
+/**
+ * TanStack Query hook for flow query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useFlowDryRunQuery(serverQuery, { skip: !isFlowMode })
+ * ```
+ */
+export declare function useFlowDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: FlowDebugDataEntry;
+    refetch: () => void;
+};
+export type RetentionDebugDataEntry = DebugDataEntry;
+/**
+ * TanStack Query hook for retention query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useRetentionDryRunQuery(serverQuery, { skip: !isRetentionMode })
+ * ```
+ */
+export declare function useRetentionDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: RetentionDebugDataEntry;
+    refetch: () => void;
+};

package/dist/cjs/client/hooks/queries/useExplainAI.d.ts

@@ -0,0 +1,62 @@
+import { ExplainResult, AIExplainAnalysis } from '../../types.js';
+export interface UseExplainAIOptions {
+    /**
+     * Custom AI endpoint for explain analysis
+     * @default '/api/ai/explain/analyze'
+     */
+    aiEndpoint?: string;
+}
+export interface UseExplainAIResult {
+    /** The AI analysis result */
+    analysis: AIExplainAnalysis | null;
+    /** Whether AI analysis is in progress */
+    isAnalyzing: boolean;
+    /** Error if AI analysis failed */
+    error: Error | null;
+    /**
+     * Trigger AI analysis of an explain result
+     * @param explainResult - The EXPLAIN result to analyze
+     * @param query - The original semantic query
+     */
+    analyze: (explainResult: ExplainResult, query: unknown) => void;
+    /** Clear the analysis result */
+    clearAnalysis: () => void;
+}
+/**
+ * Query key for AI explain analysis
+ */
+export declare const EXPLAIN_AI_QUERY_KEY: readonly ["cube", "explain", "ai"];
+/**
+ * TanStack Query hook for AI analysis of EXPLAIN plans
+ *
+ * This hook uses useMutation to call the AI endpoint and analyze execution plans,
+ * providing actionable recommendations for performance improvement.
+ *
+ * Recommendations focus on what users CAN control:
+ * - Index creation (with CREATE INDEX statements)
+ * - Table structure changes
+ * - Cube definition improvements (segments, pre-aggregations, joins)
+ *
+ * Usage:
+ * ```tsx
+ * const { analysis, isAnalyzing, analyze } = useExplainAI()
+ *
+ * // After running EXPLAIN
+ * if (explainResult) {
+ *   <button onClick={() => analyze(explainResult, query)}>
+ *     {isAnalyzing ? 'Analyzing...' : 'Analyze with AI'}
+ *   </button>
+ * }
+ *
+ * // Display recommendations
+ * {analysis?.recommendations.map(rec => (
+ *   <div key={rec.title}>
+ *     <h4>{rec.title}</h4>
+ *     <p>{rec.description}</p>
+ *     {rec.sql && <pre>{rec.sql}</pre>}
+ *     {rec.cubeCode && <pre>{rec.cubeCode}</pre>}
+ *   </div>
+ * ))}
+ * ```
+ */
+export declare function useExplainAI(options?: UseExplainAIOptions): UseExplainAIResult;

package/dist/cjs/client/hooks/queries/useExplainQuery.d.ts

@@ -0,0 +1,62 @@
+import { CubeQuery, ExplainResult, ExplainOptions } from '../../types.js';
+/**
+ * Query type that can be explained - includes standard queries, funnel queries, flow queries, and retention queries
+ */
+export type ExplainableQuery = CubeQuery | {
+    funnel: unknown;
+} | {
+    flow: unknown;
+} | {
+    retention: unknown;
+} | unknown;
+/**
+ * Create a stable query key for explain
+ */
+export declare function createExplainQueryKey(query: ExplainableQuery | null, options?: ExplainOptions): readonly unknown[];
+export interface UseExplainQueryOptions {
+    /**
+     * Whether to skip the query (prevent execution even when triggered)
+     * @default false
+     */
+    skip?: boolean;
+}
+export interface UseExplainQueryResult {
+    /** The explain result from the server */
+    explainResult: ExplainResult | null;
+    /** Whether the explain query is loading */
+    isLoading: boolean;
+    /** Whether an explain has been triggered */
+    hasRun: boolean;
+    /** Error if explain failed */
+    error: Error | null;
+    /**
+     * Manually trigger the explain query
+     * @param options - Optional explain options (e.g., { analyze: true } for actual timing)
+     */
+    runExplain: (options?: ExplainOptions) => void;
+    /** Clear the explain result */
+    clearExplain: () => void;
+}
+/**
+ * TanStack Query hook for EXPLAIN PLAN execution
+ *
+ * Unlike useDryRunQuery, this hook is manually triggered via `runExplain()`.
+ * This is intentional because:
+ * 1. EXPLAIN queries have performance overhead
+ * 2. EXPLAIN ANALYZE actually executes the query
+ * 3. Users should explicitly choose when to run explain
+ *
+ * Supports standard queries, funnel queries, and flow queries.
+ *
+ * Usage:
+ * ```tsx
+ * const { explainResult, isLoading, runExplain } = useExplainQuery(query, { skip: !isValidQuery })
+ *
+ * // Trigger explain
+ * <button onClick={() => runExplain()}>Explain Plan</button>
+ *
+ * // Trigger explain with timing
+ * <button onClick={() => runExplain({ analyze: true })}>Explain with Timing</button>
+ * ```
+ */
+export declare function useExplainQuery(query: ExplainableQuery | null, options?: UseExplainQueryOptions): UseExplainQueryResult;

package/dist/cjs/client/hooks/queries/useFlowQuery.d.ts

@@ -0,0 +1,72 @@
+import { ServerFlowQuery, FlowChartData } from '../../types/flow.js';
+/**
+ * Options for useFlowQuery hook
+ */
+export interface UseFlowQueryOptions {
+    /** Skip query execution */
+    skip?: boolean;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Callback when query completes successfully */
+    onComplete?: (data: FlowChartData) => void;
+    /** Callback when query fails */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result from useFlowQuery hook
+ */
+export interface UseFlowQueryResult {
+    /** Transformed flow chart data (nodes and links) */
+    data: FlowChartData | null;
+    /** Raw data from server */
+    rawData: unknown[] | null;
+    /** Cache metadata when served from cache */
+    cacheInfo?: {
+        hit: true;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    } | null;
+    /** Is initial load in progress */
+    isLoading: boolean;
+    /** Is refetch in progress */
+    isFetching: boolean;
+    /** Is waiting for debounce */
+    isDebouncing: boolean;
+    /** Is executing (loading or fetching) */
+    isExecuting: boolean;
+    /** Error if query failed */
+    error: Error | null;
+    /** Refetch the query. Pass { bustCache: true } to bypass client and server caches. */
+    refetch: (options?: {
+        bustCache?: boolean;
+    }) => void;
+    /** Reset the query cache */
+    reset: () => void;
+    /** The server query being executed */
+    serverQuery: ServerFlowQuery | null;
+    /**
+     * Whether the query needs to be refreshed (manual refresh mode only).
+     * True when the current flow config differs from the last executed query.
+     */
+    needsRefresh: boolean;
+}
+/**
+ * Hook for server-side flow query execution
+ *
+ * Usage:
+ * ```tsx
+ * const { data, isLoading, error } = useFlowQuery(serverFlowQuery, {
+ *   debounceMs: 300,
+ *   skip: !isConfigured
+ * })
+ *
+ * // Results available after single server request
+ * <SankeyChart data={data} />
+ * ```
+ */
+export declare function useFlowQuery(query: ServerFlowQuery | null, options?: UseFlowQueryOptions): UseFlowQueryResult;
+/**
+ * Create a stable query key for flow queries
+ */
+export declare function createFlowQueryKey(query: ServerFlowQuery | null): readonly unknown[];

package/dist/cjs/client/hooks/queries/useFunnelQuery.d.ts

@@ -0,0 +1,20 @@
+import { FunnelConfig, UseFunnelQueryOptions, UseFunnelQueryResult } from '../../types/funnel.js';
+/**
+ * Hook for server-side funnel query execution
+ *
+ * Usage:
+ * ```tsx
+ * const { chartData, isExecuting, error } = useFunnelQuery(config, {
+ *   debounceMs: 300,
+ *   skip: !hasBindingKey
+ * })
+ *
+ * // Results available after single server request
+ * <FunnelChart data={chartData} />
+ * ```
+ */
+export declare function useFunnelQuery(config: FunnelConfig | null, options?: UseFunnelQueryOptions): UseFunnelQueryResult;
+/**
+ * Create a stable query key for funnel queries
+ */
+export declare function createFunnelQueryKey(config: FunnelConfig | null): readonly unknown[];

package/dist/cjs/client/hooks/queries/useMultiCubeLoadQuery.d.ts

@@ -0,0 +1,70 @@
+import { MultiQueryConfig, CubeResultSet } from '../../types.js';
+/**
+ * Create a stable query key for multi-query
+ */
+export declare function createMultiQueryKey(config: MultiQueryConfig | null): readonly unknown[];
+export interface UseMultiCubeLoadQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+    /**
+     * Whether to reset result set when query changes
+     * @default true
+     */
+    resetResultSetOnChange?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 60 * 1000 (1 minute)
+     */
+    staleTime?: number;
+    /**
+     * Whether to keep previous data while loading new data
+     * @default true
+     */
+    keepPreviousData?: boolean;
+}
+export interface UseMultiCubeLoadQueryResult {
+    /** Merged data from all queries */
+    data: unknown[] | null;
+    /** Individual result sets from each query */
+    resultSets: (CubeResultSet | null)[] | null;
+    /** Per-query raw data */
+    perQueryData: (unknown[] | null)[] | null;
+    /** Whether any query is still loading (initial load) */
+    isLoading: boolean;
+    /** Whether any query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether query is debouncing (waiting for user to stop typing) */
+    isDebouncing: boolean;
+    /** First error encountered */
+    error: Error | null;
+    /** Per-query errors */
+    errors: (Error | null)[];
+    /** The debounced config that was executed */
+    debouncedConfig: MultiQueryConfig | null;
+    /** Whether the current config is valid */
+    isValidConfig: boolean;
+    /** Manually refetch the data. Pass { bustCache: true } to bypass client and server caches. */
+    refetch: (options?: {
+        bustCache?: boolean;
+    }) => void;
+}
+/**
+ * TanStack Query hook for loading multi-cube data with debouncing
+ *
+ * Usage:
+ * ```tsx
+ * const { data, isLoading, error } = useMultiCubeLoadQuery(config, {
+ *   debounceMs: 300,
+ *   skip: !isMultiQueryMode
+ * })
+ * ```
+ */
+export declare function useMultiCubeLoadQuery(config: MultiQueryConfig | null, options?: UseMultiCubeLoadQueryOptions): UseMultiCubeLoadQueryResult;