@payloadcms/drizzle 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/queries/getTableColumnFromPath.js

@@ -1,5 +1,5 @@
-import { and, eq, getTableName, like, sql } from 'drizzle-orm';
-import { APIError, getFieldByPath } from 'payload';
+import { and, eq, getTableName, isNull, like, notInArray, or, sql } from 'drizzle-orm';
+import { APIError, getBranchPredicateSync, getFieldByPath, resolveBranchReadState } from 'payload';
 import { fieldShouldBeLocalized, tabHasName } from 'payload/shared';
 import toSnakeCase from 'to-snake-case';
 import { validate as uuidValidate } from 'uuid';
@@ -9,20 +9,98 @@ import { jsonBuildObject } from '../utilities/json.js';
 import { DistinctSymbol } from '../utilities/rawConstraint.js';
 import { resolveBlockTableName } from '../utilities/validateExistingBlockIsIdentical.js';
 import { addJoinTable } from './addJoinTable.js';
+import { buildBranchVisibility } from './buildBranchVisibility.js';
 import { getTableAlias } from './getTableAlias.js';
+import { appendFieldToStoragePath, resolveRelationshipPath } from './resolveRelationshipPath.js';
+const getRelationshipJoinCondition = ({ adapter, collectionSlug, relationshipID, req, table, value })=>{
+    const branchReadState = resolveBranchReadState({
+        collectionSlug,
+        req
+    });
+    const branchPredicate = branchReadState.useBranching ? null : getBranchPredicateSync({
+        collectionSlug,
+        req
+    });
+    const shouldMatchCanonicalID = Boolean(table._branchDocID && (branchReadState.useBranching || branchPredicate || value === DistinctSymbol));
+    const identityCondition = shouldMatchCanonicalID ? or(eq(table.id, relationshipID), eq(table._branchDocID, relationshipID)) : eq(table.id, relationshipID);
+    const branchCondition = getBranchTableCondition({
+        adapter,
+        collectionSlug,
+        req,
+        table
+    });
+    return branchCondition ? and(identityCondition, branchCondition) : identityCondition;
+};
+const getBranchTableCondition = ({ adapter, collectionSlug, req, table })=>{
+    const branchReadState = resolveBranchReadState({
+        collectionSlug,
+        req
+    });
+    if (branchReadState.useBranching) {
+        return buildBranchVisibility({
+            adapter,
+            branch: branchReadState.branch,
+            collectionSlug,
+            table
+        });
+    }
+    const branchPredicate = getBranchPredicateSync({
+        collectionSlug,
+        req
+    });
+    return branchPredicate ? buildBranchPredicateCondition({
+        table,
+        where: branchPredicate
+    }) : undefined;
+};
+const buildBranchPredicateCondition = ({ table, where })=>{
+    const conditions = [];
+    for (const [fieldName, condition] of Object.entries(where)){
+        if ((fieldName === 'and' || fieldName === 'or') && Array.isArray(condition)) {
+            const nestedConditions = condition.map((nestedWhere)=>buildBranchPredicateCondition({
+                    table,
+                    where: nestedWhere
+                })).filter((nestedCondition)=>Boolean(nestedCondition));
+            const nestedResult = fieldName === 'and' ? and(...nestedConditions) : or(...nestedConditions);
+            if (nestedResult) {
+                conditions.push(nestedResult);
+            }
+            continue;
+        }
+        const column = table[fieldName];
+        if (!column || !condition || typeof condition !== 'object') {
+            continue;
+        }
+        if ('equals' in condition) {
+            conditions.push(condition.equals === null ? isNull(column) : eq(column, condition.equals));
+        }
+        if ('not_in' in condition && Array.isArray(condition.not_in) && condition.not_in.length > 0) {
+            conditions.push(notInArray(column, condition.not_in));
+        }
+    }
+    return conditions.length === 1 ? conditions[0] : and(...conditions);
+};
 /**
- * Transforms path to table and column name or to a list of OR columns
- * Adds tables to `join`
- * @returns TableColumn
- */ export const getTableColumnFromPath = ({ adapter, aliasTable, collectionPath, columnPrefix = '', constraintPath: incomingConstraintPath, constraints = [], fields, joins, locale: incomingLocale, parentAliasTable, parentIsLocalized, pathSegments: incomingSegments, rootTableName: incomingRootTableName, selectFields, selectLocale, tableName, tableNameSuffix = '', value })=>{
+ * Resolves a field path to the database table and column that store its value.
+ *
+ * While walking through relationships, arrays, and blocks, the function adds the joins required
+ * to reach the final column. Table aliases are used when the path is resolved inside a subquery.
+ *
+ * @example
+ * Resolving `movies.name` adds joins from the parent collection to its relationship table and then
+ * to the `movies` table. The returned column is `movies.name`.
+ *
+ * @returns The final field and column, plus any extra constraints discovered while resolving it.
+ */ export const getTableColumnFromPath = ({ adapter, aliasTable, collectionPath, columnPrefix = '', constraintPath: incomingConstraintPath, constraints = [], fields, joins, locale: incomingLocale, parentAliasTable, parentIsLocalized, pathSegments: incomingSegments, req, rootTableName: incomingRootTableName, selectFields, selectLocale, tableName, tableNameSuffix = '', value })=>{
     const fieldPath = incomingSegments[0];
     let locale = incomingLocale;
     const rootTableName = incomingRootTableName || tableName;
+    const tableContainingField = parentAliasTable ?? aliasTable ?? adapter.tables[rootTableName];
     let constraintPath = incomingConstraintPath || '';
     const field = fields.find((fieldToFind)=>fieldToFind.name === fieldPath);
     let newTableName = tableName;
     if (!field && fieldPath === 'id') {
-        selectFields.id = adapter.tables[newTableName].id;
+        const idTable = aliasTable ?? adapter.tables[newTableName];
         return {
             columnName: 'id',
             constraints,
@@ -30,7 +108,7 @@ import { getTableAlias } from './getTableAlias.js';
                 name: 'id',
                 type: isUUIDType(adapter.idType) ? 'text' : 'number'
             },
-            table: adapter.tables[newTableName]
+            table: idTable
         };
     }
     let localizedPathQuery = false;
@@ -38,6 +116,10 @@ import { getTableAlias } from './getTableAlias.js';
         const pathSegments = [
             ...incomingSegments
         ];
+        const fieldStoragePath = appendFieldToStoragePath({
+            field,
+            path: constraintPath
+        });
         const isFieldLocalized = fieldShouldBeLocalized({
             field,
             parentIsLocalized
@@ -57,7 +139,7 @@ import { getTableAlias } from './getTableAlias.js';
                 {
                     newTableName = adapter.tableNameMap.get(`${tableName}_${tableNameSuffix}${toSnakeCase(field.name)}`);
                     const arrayParentTable = aliasTable || adapter.tables[tableName];
-                    constraintPath = `${constraintPath}${field.name}.%.`;
+                    constraintPath = `${fieldStoragePath}.`;
                     if (locale && isFieldLocalized && adapter.payload.config.localization) {
                         const conditions = [
                             eq(arrayParentTable.id, adapter.tables[newTableName]._parentID)
@@ -93,6 +175,7 @@ import { getTableAlias } from './getTableAlias.js';
                         parentAliasTable: aliasTable,
                         parentIsLocalized: parentIsLocalized || field.localized,
                         pathSegments: pathSegments.slice(1),
+                        req,
                         rootTableName,
                         selectFields,
                         selectLocale,
@@ -140,7 +223,6 @@ import { getTableAlias } from './getTableAlias.js';
                     const hasBlockField = field.blocks.some((_block)=>{
                         const block = typeof _block === 'string' ? adapter.payload.blocks[_block] : _block;
                         newTableName = resolveBlockTableName(block, adapter.tableNameMap.get(`${tableName}_blocks_${toSnakeCase(block.slug)}`));
-                        constraintPath = `${constraintPath}${field.name}.%.`;
                         let result;
                         const blockConstraints = [];
                         const blockSelectFields = {};
@@ -170,13 +252,14 @@ import { getTableAlias } from './getTableAlias.js';
                             result = getTableColumnFromPath({
                                 adapter,
                                 collectionPath,
-                                constraintPath,
+                                constraintPath: `${fieldStoragePath}.`,
                                 constraints: blockConstraints,
                                 fields: block.flattenedFields,
                                 joins: newJoins,
                                 locale,
                                 parentIsLocalized: parentIsLocalized || field.localized,
                                 pathSegments: pathSegments.slice(1),
+                                req,
                                 rootTableName,
                                 selectFields: blockSelectFields,
                                 selectLocale,
@@ -236,13 +319,14 @@ import { getTableAlias } from './getTableAlias.js';
                         aliasTable,
                         collectionPath,
                         columnPrefix: `${columnPrefix}${field.name}_`,
-                        constraintPath: `${constraintPath}${field.name}.`,
+                        constraintPath: `${fieldStoragePath}.`,
                         constraints,
                         fields: field.flattenedFields,
                         joins,
                         locale,
                         parentIsLocalized: parentIsLocalized || field.localized,
                         pathSegments: pathSegments.slice(1),
+                        req,
                         rootTableName,
                         selectFields,
                         selectLocale,
@@ -257,6 +341,15 @@ import { getTableAlias } from './getTableAlias.js';
                         throw new APIError('Not supported');
                     }
                     const newCollectionPath = pathSegments.slice(1).join('.');
+                    // Filtering through a polymorphic `on` relationship is not supported: it is stored in the
+                    // `_rels` table with no direct column to correlate on, which would otherwise build invalid SQL.
+                    const onRelationshipField = getFieldByPath({
+                        fields: adapter.payload.collections[field.collection].config.flattenedFields,
+                        path: field.on
+                    })?.field;
+                    if (onRelationshipField && (onRelationshipField.type === 'relationship' || onRelationshipField.type === 'upload') && Array.isArray(onRelationshipField.relationTo)) {
+                        throw new APIError('Not supported');
+                    }
                     if (field.hasMany) {
                         const relationTableName = `${adapter.tableNameMap.get(toSnakeCase(field.collection))}${adapter.relationshipsSuffix}`;
                         const existingTable = joins.find((e)=>e.queryPath === `${constraintPath}${field.name}._rels`);
@@ -273,7 +366,7 @@ import { getTableAlias } from './getTableAlias.js';
                         }
                         if (!existingTable) {
                             addJoinTable({
-                                condition: and(eq(adapter.tables[rootTableName].id, aliasRelationshipTable[`${relationshipField.field.relationTo}ID`]), like(aliasRelationshipTable.path, field.on)),
+                                condition: and(eq(tableContainingField.id, aliasRelationshipTable[`${relationshipField.field.relationTo}ID`]), like(aliasRelationshipTable.path, field.on)),
                                 joins,
                                 queryPath: `${constraintPath}${field.name}._rels`,
                                 table: aliasRelationshipTable
@@ -300,8 +393,15 @@ import { getTableAlias } from './getTableAlias.js';
                             tableName: relationshipTableName
                         }).newAliasTable;
                         if (!existingMainTable) {
+                            const branchCondition = getBranchTableCondition({
+                                adapter,
+                                collectionSlug: field.collection,
+                                req,
+                                table: relationshipTable
+                            });
+                            const relationshipCondition = eq(aliasRelationshipTable.parent, relationshipTable.id);
                             joins.push({
-                                condition: eq(aliasRelationshipTable.parent, relationshipTable.id),
+                                condition: branchCondition ? and(relationshipCondition, branchCondition) : relationshipCondition,
                                 queryPath: `${constraintPath}${field.name}`,
                                 table: relationshipTable
                             });
@@ -311,12 +411,13 @@ import { getTableAlias } from './getTableAlias.js';
                             aliasTable: relationshipTable,
                             collectionPath: newCollectionPath,
                             constraints,
-                            // relationshipFields are fields from a different collection => no parentIsLocalized
                             fields: relationshipFields,
                             joins,
                             locale,
+                            // A join reads from a different collection, so localization does not carry over
                             parentIsLocalized: false,
                             pathSegments: pathSegments.slice(1),
+                            req,
                             rootTableName: relationshipTableName,
                             selectFields,
                             selectLocale,
@@ -347,13 +448,29 @@ import { getTableAlias } from './getTableAlias.js';
                                 table: arrayAliasTable
                             });
                             joins.push({
-                                condition: eq(newAliasTable.id, arrayAliasTable._parentID),
+                                condition: (()=>{
+                                    const relationshipCondition = eq(newAliasTable['id'], arrayAliasTable._parentID);
+                                    const branchCondition = getBranchTableCondition({
+                                        adapter,
+                                        collectionSlug: field.collection,
+                                        req,
+                                        table: newAliasTable
+                                    });
+                                    return branchCondition ? and(relationshipCondition, branchCondition) : relationshipCondition;
+                                })(),
                                 queryPath: `${constraintPath}${field.name}`,
                                 table: newAliasTable
                             });
                         } else {
+                            const relationshipCondition = eq(newAliasTable[field.on.replaceAll('.', '_')], aliasTable ? aliasTable.id : adapter.tables[tableName].id);
+                            const branchCondition = getBranchTableCondition({
+                                adapter,
+                                collectionSlug: field.collection,
+                                req,
+                                table: newAliasTable
+                            });
                             joins.push({
-                                condition: eq(newAliasTable[field.on.replaceAll('.', '_')], aliasTable ? aliasTable.id : adapter.tables[tableName].id),
+                                condition: branchCondition ? and(relationshipCondition, branchCondition) : relationshipCondition,
                                 queryPath: `${constraintPath}${field.name}`,
                                 table: newAliasTable
                             });
@@ -379,8 +496,10 @@ import { getTableAlias } from './getTableAlias.js';
                         fields: adapter.payload.collections[field.collection].config.flattenedFields,
                         joins,
                         locale,
-                        parentIsLocalized: parentIsLocalized || field.localized,
+                        // A join reads from a different collection, so localization does not carry over
+                        parentIsLocalized: false,
                         pathSegments: pathSegments.slice(1),
+                        req,
                         selectFields,
                         tableName: newTableName,
                         value
@@ -398,14 +517,14 @@ import { getTableAlias } from './getTableAlias.js';
                             columnName = 'number';
                         }
                         newTableName = `${rootTableName}_${tableType}`;
-                        const existingTable = joins.find((e)=>e.queryPath === `${constraintPath}${field.name}`);
+                        const existingTable = joins.find((e)=>e.queryPath === fieldStoragePath);
                         const table = existingTable?.table ?? getTableAlias({
                             adapter,
                             tableName: newTableName
                         }).newAliasTable;
                         const joinConstraints = [
-                            eq(adapter.tables[rootTableName].id, table.parent),
-                            like(table.path, `${constraintPath}${field.name}`)
+                            eq(tableContainingField.id, table.parent),
+                            like(table.path, fieldStoragePath)
                         ];
                         if (locale && isFieldLocalized && adapter.payload.config.localization) {
                             const conditions = [
@@ -417,14 +536,14 @@ import { getTableAlias } from './getTableAlias.js';
                             addJoinTable({
                                 condition: and(...conditions),
                                 joins,
-                                queryPath: `${constraintPath}${field.name}`,
+                                queryPath: fieldStoragePath,
                                 table
                             });
                         } else {
                             addJoinTable({
                                 condition: and(...joinConstraints),
                                 joins,
-                                queryPath: `${constraintPath}${field.name}`,
+                                queryPath: fieldStoragePath,
                                 table
                             });
                         }
@@ -441,10 +560,23 @@ import { getTableAlias } from './getTableAlias.js';
             case 'upload':
                 {
                     const newCollectionPath = pathSegments.slice(1).join('.');
+                    const relationshipQueryPath = `${getTableName(tableContainingField)}.${fieldStoragePath}._rels`;
+                    const targetQueryPath = `${getTableName(tableContainingField)}.${fieldStoragePath}._target`;
                     if (Array.isArray(field.relationTo) || field.hasMany) {
+                        const relationshipPath = resolveRelationshipPath({
+                            adapter,
+                            fields,
+                            locale,
+                            parentIsLocalized,
+                            path: field.name,
+                            pathPrefix: constraintPath
+                        });
+                        if (!relationshipPath) {
+                            throw new APIError(`Relationship path could not be resolved: ${collectionPath}`);
+                        }
                         let relationshipFields;
                         const relationTableName = `${rootTableName}${adapter.relationshipsSuffix}`;
-                        const existingJoin = joins.find((e)=>e.queryPath === `${constraintPath}.${field.name}`);
+                        const existingJoin = joins.find((e)=>e.queryPath === relationshipQueryPath);
                         let aliasRelationshipTable;
                         let aliasRelationshipTableName;
                         if (existingJoin) {
@@ -458,30 +590,28 @@ import { getTableAlias } from './getTableAlias.js';
                             aliasRelationshipTable = res.newAliasTable;
                             aliasRelationshipTableName = res.newAliasTableName;
                         }
-                        if (selectLocale && isFieldLocalized && adapter.payload.config.localization) {
+                        if (selectLocale && relationshipPath.isLocalized && adapter.payload.config.localization) {
                             selectFields._locale = aliasRelationshipTable.locale;
                         }
                         // Join in the relationships table
-                        if (locale && isFieldLocalized && adapter.payload.config.localization) {
+                        if (relationshipPath.locale && relationshipPath.locale !== 'all' && relationshipPath.isLocalized && adapter.payload.config.localization) {
                             const conditions = [
-                                eq((parentAliasTable || aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent),
-                                like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)
+                                eq(tableContainingField.id, aliasRelationshipTable.parent),
+                                like(aliasRelationshipTable.path, relationshipPath.path)
                             ];
-                            if (locale !== 'all') {
-                                conditions.push(eq(aliasRelationshipTable.locale, locale));
-                            }
+                            conditions.push(eq(aliasRelationshipTable.locale, relationshipPath.locale));
                             addJoinTable({
                                 condition: and(...conditions),
                                 joins,
-                                queryPath: `${constraintPath}.${field.name}`,
+                                queryPath: relationshipQueryPath,
                                 table: aliasRelationshipTable
                             });
                         } else {
                             // Join in the relationships table
                             addJoinTable({
-                                condition: and(eq((parentAliasTable || aliasTable || adapter.tables[rootTableName]).id, aliasRelationshipTable.parent), like(aliasRelationshipTable.path, `${constraintPath}${field.name}`)),
+                                condition: and(eq(tableContainingField.id, aliasRelationshipTable.parent), like(aliasRelationshipTable.path, relationshipPath.path)),
                                 joins,
-                                queryPath: `${constraintPath}.${field.name}`,
+                                queryPath: relationshipQueryPath,
                                 table: aliasRelationshipTable
                             });
                         }
@@ -492,15 +622,31 @@ import { getTableAlias } from './getTableAlias.js';
                             newTableName = adapter.tableNameMap.get(toSnakeCase(relationshipConfig.slug));
                             // parent to relationship join table
                             relationshipFields = relationshipConfig.flattenedFields;
-                            ({ newAliasTable } = getTableAlias({
-                                adapter,
-                                tableName: newTableName
-                            }));
-                            joins.push({
-                                condition: eq(newAliasTable.id, aliasRelationshipTable[`${field.relationTo}ID`]),
-                                table: newAliasTable
-                            });
-                            if (newCollectionPath === '' || newCollectionPath === 'id') {
+                            const existingTargetJoin = joins.find((join)=>join.queryPath === targetQueryPath);
+                            if (existingTargetJoin) {
+                                newAliasTable = existingTargetJoin.table;
+                            } else {
+                                ;
+                                ({ newAliasTable } = getTableAlias({
+                                    adapter,
+                                    tableName: newTableName
+                                }));
+                                const relationshipID = aliasRelationshipTable[`${field.relationTo}ID`];
+                                const condition = getRelationshipJoinCondition({
+                                    adapter,
+                                    collectionSlug: field.relationTo,
+                                    relationshipID,
+                                    req,
+                                    table: newAliasTable,
+                                    value
+                                });
+                                joins.push({
+                                    condition,
+                                    queryPath: targetQueryPath,
+                                    table: newAliasTable
+                                });
+                            }
+                            if (newCollectionPath === '' || newCollectionPath === 'id' && !existingTargetJoin) {
                                 return {
                                     columnName: `${field.relationTo}ID`,
                                     constraints,
@@ -597,33 +743,35 @@ import { getTableAlias } from './getTableAlias.js';
                             aliasTable: newAliasTable,
                             collectionPath: newCollectionPath,
                             constraints,
-                            // relationshipFields are fields from a different collection => no parentIsLocalized
                             fields: relationshipFields,
                             joins,
                             locale,
+                            // A relationship jumps to a different collection, so localization does not carry over
                             parentIsLocalized: false,
                             pathSegments: pathSegments.slice(1),
+                            req,
                             rootTableName: newTableName,
                             selectFields,
                             selectLocale,
                             tableName: newTableName,
                             value
                         });
-                    } else if (pathSegments.length > 1 && !(pathSegments.length === 2 && pathSegments[1] === 'id')) {
+                    } else if (pathSegments.length > 1 && (!(pathSegments.length === 2 && pathSegments[1] === 'id') || joins.some((join)=>join.queryPath === targetQueryPath))) {
                         // simple relationships
                         const columnName = `${columnPrefix}${field.name}`;
                         const newTableName = adapter.tableNameMap.get(toSnakeCase(adapter.payload.collections[field.relationTo].config.slug));
-                        const { newAliasTable } = getTableAlias({
+                        const existingTargetJoin = joins.find((join)=>join.queryPath === targetQueryPath);
+                        const newAliasTable = existingTargetJoin?.table ?? getTableAlias({
                             adapter,
                             tableName: newTableName
-                        });
-                        if (isFieldLocalized && adapter.payload.config.localization) {
+                        }).newAliasTable;
+                        if (!existingTargetJoin && isFieldLocalized && adapter.payload.config.localization) {
                             const { newAliasTable: aliasLocaleTable } = getTableAlias({
                                 adapter,
                                 tableName: `${rootTableName}${adapter.localesSuffix}`
                             });
                             const condtions = [
-                                eq(aliasLocaleTable._parentID, adapter.tables[rootTableName].id)
+                                eq(aliasLocaleTable._parentID, tableContainingField.id)
                             ];
                             if (selectLocale) {
                                 selectFields._locale = aliasLocaleTable._locale;
@@ -637,13 +785,32 @@ import { getTableAlias } from './getTableAlias.js';
                                 joins,
                                 table: localesTable
                             });
+                            const condition = getRelationshipJoinCondition({
+                                adapter,
+                                collectionSlug: field.relationTo,
+                                relationshipID: localesTable[columnName],
+                                req,
+                                table: newAliasTable,
+                                value
+                            });
                             joins.push({
-                                condition: eq(localesTable[columnName], newAliasTable.id),
+                                condition,
+                                queryPath: targetQueryPath,
                                 table: newAliasTable
                             });
-                        } else {
+                        } else if (!existingTargetJoin) {
+                            const relationshipID = aliasTable ? aliasTable[columnName] : adapter.tables[tableName][columnName];
+                            const condition = getRelationshipJoinCondition({
+                                adapter,
+                                collectionSlug: field.relationTo,
+                                relationshipID,
+                                req,
+                                table: newAliasTable,
+                                value
+                            });
                             joins.push({
-                                condition: eq(newAliasTable.id, aliasTable ? aliasTable[columnName] : adapter.tables[tableName][columnName]),
+                                condition,
+                                queryPath: targetQueryPath,
                                 table: newAliasTable
                             });
                         }
@@ -656,8 +823,10 @@ import { getTableAlias } from './getTableAlias.js';
                             fields: adapter.payload.collections[field.relationTo].config.flattenedFields,
                             joins,
                             locale,
-                            parentIsLocalized: parentIsLocalized || field.localized,
+                            // A relationship jumps to a different collection, so localization does not carry over
+                            parentIsLocalized: false,
                             pathSegments: pathSegments.slice(1),
+                            req,
                             selectFields,
                             tableName: newTableName,
                             value
@@ -707,13 +876,14 @@ import { getTableAlias } from './getTableAlias.js';
                             aliasTable,
                             collectionPath,
                             columnPrefix: `${columnPrefix}${field.name}_`,
-                            constraintPath: `${constraintPath}${field.name}.`,
+                            constraintPath: `${fieldStoragePath}.`,
                             constraints,
                             fields: field.flattenedFields,
                             joins,
                             locale,
                             parentIsLocalized: parentIsLocalized || field.localized,
                             pathSegments: pathSegments.slice(1),
+                            req,
                             rootTableName,
                             selectFields,
                             selectLocale,
@@ -734,6 +904,7 @@ import { getTableAlias } from './getTableAlias.js';
                         locale,
                         parentIsLocalized: parentIsLocalized || field.localized,
                         pathSegments: pathSegments.slice(1),
+                        req,
                         rootTableName,
                         selectFields,
                         selectLocale,