@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/src/concepts/CallQueryComponent__.ts

@@ -22,19 +22,20 @@ import type MemberExpression from './MemberExpression__';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
+import TypeAnnotation from './TypeAnnotation__';
+import QuerySelectExpression from './QuerySelectExpression__';
+import QueryFromExpression from './QueryFromExpression__';
 import LogicItem from './LogicItem__';
-import type TypeAnnotation from './TypeAnnotation__';
-import type QuerySelectExpression from './QuerySelectExpression__';
-import type QueryFromExpression from './QueryFromExpression__';
-import type QueryGroupByExpression from './QueryGroupByExpression__';
-import type QueryOrderByExpression from './QueryOrderByExpression__';
-import type QueryLimitExpression from './QueryLimitExpression__';
+import QueryGroupByExpression from './QueryGroupByExpression__';
+import QueryOrderByExpression from './QueryOrderByExpression__';
+import QueryLimitExpression from './QueryLimitExpression__';
 
 /**
  * 数据查询
@@ -43,7 +44,11 @@ import type QueryLimitExpression from './QueryLimitExpression__';
 export class CallQueryComponent extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'CallQueryComponent';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
@@ -53,14 +58,13 @@ export class CallQueryComponent extends LogicItem {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'CallQueryComponent';
-
   /**
    * 类型
    */
   @property({
     objectRef: 'TypeAnnotation',
   })
-  typeAnnotation!: TypeAnnotation;
+  typeAnnotation: TypeAnnotation;
 
   /**
    * select
@@ -68,7 +72,7 @@ export class CallQueryComponent extends LogicItem {
   @property({
     objectRef: 'QuerySelectExpression',
   })
-  select!: QuerySelectExpression;
+  select: QuerySelectExpression;
 
   /**
    * from
@@ -76,7 +80,7 @@ export class CallQueryComponent extends LogicItem {
   @property({
     objectRef: 'QueryFromExpression',
   })
-  from!: QueryFromExpression;
+  from: QueryFromExpression;
 
   /**
    * where
@@ -84,7 +88,7 @@ export class CallQueryComponent extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  where!: LogicItem;
+  where: LogicItem;
 
   /**
    * where 草稿态
@@ -112,7 +116,7 @@ export class CallQueryComponent extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  having!: LogicItem;
+  having: LogicItem;
 
   /**
    * having 草稿态
@@ -140,13 +144,15 @@ export class CallQueryComponent extends LogicItem {
   @property({
     objectRef: 'QueryLimitExpression',
   })
-  limit!: QueryLimitExpression;
+  limit: QueryLimitExpression;
 
   /**
    * 查询组件的局部版本
    */
-  @property()
-  ideVersion!: string;
+  @property({
+    objectRef: '',
+  })
+  ideVersion: string;
 
   /**
    * @param source 需要合并的部分参数
@@ -362,225 +368,212 @@ export class CallQueryComponent extends LogicItem {
   }
 
   /**
-   * 插入查询分组
+   * 插入逻辑项
    * @internal
-   * @param queryGroupByExpressionOptions 查询分组参数
+   * @param logicItemOptions 逻辑项参数
    */
-  _insertQueryGroupByExpressionInGroupByAt(
-    queryGroupByExpressionOptions: Partial<QueryGroupByExpression>,
-    index: number,
-  ): QueryGroupByExpression;
+  _insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
   /**
-   * 插入查询分组
+   * 插入逻辑项
    * @internal
-   * @param queryGroupByExpression 已有的查询分组实例
+   * @param logicItem 已有的逻辑项实例
    */
-  _insertQueryGroupByExpressionInGroupByAt(
-    queryGroupByExpression: QueryGroupByExpression,
-    index: number,
-  ): QueryGroupByExpression;
+  _insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
 
-  _insertQueryGroupByExpressionInGroupByAt(
-    options: Partial<QueryGroupByExpression> | QueryGroupByExpression,
-    index: number,
-  ) {
-    const queryGroupByExpressionOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'groupBy' };
-    const QueryGroupByExpression = getConceptConstructor('QueryGroupByExpression');
-    let queryGroupByExpression: QueryGroupByExpression;
-    if (asserts.isQueryGroupByExpression(options)) {
+  _insertItemInHavingPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const logicItemOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'havingPlayground' };
+    const LogicItem = getConceptConstructor('LogicItem');
+    let logicItem: LogicItem;
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      queryGroupByExpression = options;
-      Object.assign(queryGroupByExpression, relationOptions);
+      logicItem = options;
+      Object.assign(logicItem, relationOptions);
     } else {
-      queryGroupByExpression = QueryGroupByExpression.from(
+      logicItem = LogicItem.from(
         {
-          ...queryGroupByExpressionOptions,
+          ...logicItemOptions,
           ...options,
         },
         this,
-        'groupBy',
+        'havingPlayground',
       );
     }
-    this.groupBy.splice(index, 0, queryGroupByExpression);
-    return queryGroupByExpression;
+    this.havingPlayground.splice(index, 0, logicItem);
+    return logicItem;
   }
 
   /**
-   * 插入查询分组
-   * @param queryGroupByExpressionOptions 查询分组参数
+   * 插入逻辑项
+   * @param logicItemOptions 逻辑项参数
    */
-  insertQueryGroupByExpressionInGroupByAt(
-    queryGroupByExpressionOptions: Partial<QueryGroupByExpression>,
-    index: number,
-  ): QueryGroupByExpression;
+  insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
   /**
-   * 插入查询分组
-   * @param queryGroupByExpression 已有的查询分组实例
+   * 插入逻辑项
+   * @param logicItem 已有的逻辑项实例
    */
-  insertQueryGroupByExpressionInGroupByAt(
-    queryGroupByExpression: QueryGroupByExpression,
-    index: number,
-  ): QueryGroupByExpression;
+  insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
 
-  insertQueryGroupByExpressionInGroupByAt(
-    options: Partial<QueryGroupByExpression> | QueryGroupByExpression,
-    index: number,
-  ) {
-    const node = this._insertQueryGroupByExpressionInGroupByAt(options as any, index);
+  insertItemInHavingPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const node = this._insertItemInHavingPlaygroundAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'groupBy',
+      parentKey: 'havingPlayground',
     });
     return node;
   }
 
   /**
-   * 添加查询分组
+   * 添加逻辑项
    * @internal
-   * @param queryGroupByExpressionOptions 查询分组参数
+   * @param logicItemOptions 逻辑项参数
    */
-  _addQueryGroupByExpressionInGroupBy(
-    queryGroupByExpressionOptions: Partial<QueryGroupByExpression>,
-  ): QueryGroupByExpression;
+  _addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
 
   /**
-   * 添加查询分组
+   * 添加逻辑项
    * @internal
-   * @param queryGroupByExpression 已有的查询分组实例
+   * @param logicItem 已有的逻辑项实例
    */
-  _addQueryGroupByExpressionInGroupBy(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
+  _addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
 
-  _addQueryGroupByExpressionInGroupBy(options?: Partial<QueryGroupByExpression> | QueryGroupByExpression) {
-    const index = this.groupBy.length;
-    return this._insertQueryGroupByExpressionInGroupByAt(options as any, index);
+  _addItemInHavingPlayground(options?: Partial<LogicItem> | LogicItem) {
+    const index = this.havingPlayground.length;
+    return this._insertItemInHavingPlaygroundAt(options as any, index);
   }
 
   /**
-   * 添加查询分组
-   * @param queryGroupByExpressionOptions 查询分组参数
+   * 添加逻辑项
+   * @param logicItemOptions 逻辑项参数
    */
-  addQueryGroupByExpressionInGroupBy(
-    queryGroupByExpressionOptions: Partial<QueryGroupByExpression>,
-  ): QueryGroupByExpression;
+  addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
 
   /**
-   * 添加查询分组
-   * @param queryGroupByExpression 已有的查询分组实例
+   * 添加逻辑项
+   * @param logicItem 已有的逻辑项实例
    */
-  addQueryGroupByExpressionInGroupBy(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
+  addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
 
-  addQueryGroupByExpressionInGroupBy(options?: Partial<QueryGroupByExpression> | QueryGroupByExpression) {
-    const node = this._addQueryGroupByExpressionInGroupBy(options as any);
-    const index = this.groupBy.indexOf(node);
+  addItemInHavingPlayground(options?: Partial<LogicItem> | LogicItem) {
+    const node = this._addItemInHavingPlayground(options as any);
+    const index = this.havingPlayground.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'groupBy',
+      parentKey: 'havingPlayground',
     });
     return node;
   }
 
   /**
-   * 插入逻辑项
+   * 插入查询分组
    * @internal
-   * @param logicItemOptions 逻辑项参数
+   * @param queryGroupByExpressionOptions 查询分组参数
    */
-  _insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+  _insertQueryGroupByExpressionAt(
+    queryGroupByExpressionOptions: Partial<QueryGroupByExpression>,
+    index: number,
+  ): QueryGroupByExpression;
 
   /**
-   * 插入逻辑项
+   * 插入查询分组
    * @internal
-   * @param logicItem 已有的逻辑项实例
+   * @param queryGroupByExpression 已有的查询分组实例
    */
-  _insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+  _insertQueryGroupByExpressionAt(
+    queryGroupByExpression: QueryGroupByExpression,
+    index: number,
+  ): QueryGroupByExpression;
 
-  _insertItemInHavingPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
-    const logicItemOptions: any = {};
-    const relationOptions = { parentNode: this, parentKey: 'havingPlayground' };
-    const LogicItem = getConceptConstructor('LogicItem');
-    let logicItem: LogicItem;
-    if (asserts.isLogicItem(options)) {
+  _insertQueryGroupByExpressionAt(options: Partial<QueryGroupByExpression> | QueryGroupByExpression, index: number) {
+    const queryGroupByExpressionOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'groupBy' };
+    const QueryGroupByExpression = getConceptConstructor('QueryGroupByExpression');
+    let queryGroupByExpression: QueryGroupByExpression;
+    if (asserts.isQueryGroupByExpression(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
-      logicItem = options;
-      Object.assign(logicItem, relationOptions);
+      queryGroupByExpression = options;
+      Object.assign(queryGroupByExpression, relationOptions);
     } else {
-      logicItem = LogicItem.from(
+      queryGroupByExpression = QueryGroupByExpression.from(
         {
-          ...logicItemOptions,
+          ...queryGroupByExpressionOptions,
           ...options,
         },
         this,
-        'havingPlayground',
+        'groupBy',
       );
     }
-    this.havingPlayground.splice(index, 0, logicItem);
-    return logicItem;
+    this.groupBy.splice(index, 0, queryGroupByExpression);
+    return queryGroupByExpression;
   }
 
   /**
-   * 插入逻辑项
-   * @param logicItemOptions 逻辑项参数
+   * 插入查询分组
+   * @param queryGroupByExpressionOptions 查询分组参数
    */
-  insertItemInHavingPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+  insertQueryGroupByExpressionAt(
+    queryGroupByExpressionOptions: Partial<QueryGroupByExpression>,
+    index: number,
+  ): QueryGroupByExpression;
 
   /**
-   * 插入逻辑项
-   * @param logicItem 已有的逻辑项实例
+   * 插入查询分组
+   * @param queryGroupByExpression 已有的查询分组实例
    */
-  insertItemInHavingPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+  insertQueryGroupByExpressionAt(queryGroupByExpression: QueryGroupByExpression, index: number): QueryGroupByExpression;
 
-  insertItemInHavingPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
-    const node = this._insertItemInHavingPlaygroundAt(options as any, index);
+  insertQueryGroupByExpressionAt(options: Partial<QueryGroupByExpression> | QueryGroupByExpression, index: number) {
+    const node = this._insertQueryGroupByExpressionAt(options as any, index);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'havingPlayground',
+      parentKey: 'groupBy',
     });
     return node;
   }
 
   /**
-   * 添加逻辑项
+   * 添加查询分组
    * @internal
-   * @param logicItemOptions 逻辑项参数
+   * @param queryGroupByExpressionOptions 查询分组参数
    */
-  _addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+  _addQueryGroupByExpression(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>): QueryGroupByExpression;
 
   /**
-   * 添加逻辑项
+   * 添加查询分组
    * @internal
-   * @param logicItem 已有的逻辑项实例
+   * @param queryGroupByExpression 已有的查询分组实例
    */
-  _addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
+  _addQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
 
-  _addItemInHavingPlayground(options?: Partial<LogicItem> | LogicItem) {
-    const index = this.havingPlayground.length;
-    return this._insertItemInHavingPlaygroundAt(options as any, index);
+  _addQueryGroupByExpression(options?: Partial<QueryGroupByExpression> | QueryGroupByExpression) {
+    const index = this.groupBy.length;
+    return this._insertQueryGroupByExpressionAt(options as any, index);
   }
 
   /**
-   * 添加逻辑项
-   * @param logicItemOptions 逻辑项参数
+   * 添加查询分组
+   * @param queryGroupByExpressionOptions 查询分组参数
    */
-  addItemInHavingPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+  addQueryGroupByExpression(queryGroupByExpressionOptions: Partial<QueryGroupByExpression>): QueryGroupByExpression;
 
   /**
-   * 添加逻辑项
-   * @param logicItem 已有的逻辑项实例
+   * 添加查询分组
+   * @param queryGroupByExpression 已有的查询分组实例
    */
-  addItemInHavingPlayground(logicItem: LogicItem): LogicItem;
+  addQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): QueryGroupByExpression;
 
-  addItemInHavingPlayground(options?: Partial<LogicItem> | LogicItem) {
-    const node = this._addItemInHavingPlayground(options as any);
-    const index = this.havingPlayground.indexOf(node);
+  addQueryGroupByExpression(options?: Partial<QueryGroupByExpression> | QueryGroupByExpression) {
+    const node = this._addQueryGroupByExpression(options as any);
+    const index = this.groupBy.indexOf(node);
     node.create({
       index,
       parentNode: this,
-      parentKey: 'havingPlayground',
+      parentKey: 'groupBy',
     });
     return node;
   }
@@ -590,7 +583,7 @@ export class CallQueryComponent extends LogicItem {
    * @internal
    * @param queryOrderByExpressionOptions 查询排序子句参数
    */
-  _insertQueryOrderByExpressionInOrderByAt(
+  _insertQueryOrderByExpressionAt(
     queryOrderByExpressionOptions: Partial<QueryOrderByExpression>,
     index: number,
   ): QueryOrderByExpression;
@@ -600,15 +593,12 @@ export class CallQueryComponent extends LogicItem {
    * @internal
    * @param queryOrderByExpression 已有的查询排序子句实例
    */
-  _insertQueryOrderByExpressionInOrderByAt(
+  _insertQueryOrderByExpressionAt(
     queryOrderByExpression: QueryOrderByExpression,
     index: number,
   ): QueryOrderByExpression;
 
-  _insertQueryOrderByExpressionInOrderByAt(
-    options: Partial<QueryOrderByExpression> | QueryOrderByExpression,
-    index: number,
-  ) {
+  _insertQueryOrderByExpressionAt(options: Partial<QueryOrderByExpression> | QueryOrderByExpression, index: number) {
     const queryOrderByExpressionOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'orderBy' };
     const QueryOrderByExpression = getConceptConstructor('QueryOrderByExpression');
@@ -635,7 +625,7 @@ export class CallQueryComponent extends LogicItem {
    * 插入查询排序子句
    * @param queryOrderByExpressionOptions 查询排序子句参数
    */
-  insertQueryOrderByExpressionInOrderByAt(
+  insertQueryOrderByExpressionAt(
     queryOrderByExpressionOptions: Partial<QueryOrderByExpression>,
     index: number,
   ): QueryOrderByExpression;
@@ -644,16 +634,10 @@ export class CallQueryComponent extends LogicItem {
    * 插入查询排序子句
    * @param queryOrderByExpression 已有的查询排序子句实例
    */
-  insertQueryOrderByExpressionInOrderByAt(
-    queryOrderByExpression: QueryOrderByExpression,
-    index: number,
-  ): QueryOrderByExpression;
+  insertQueryOrderByExpressionAt(queryOrderByExpression: QueryOrderByExpression, index: number): QueryOrderByExpression;
 
-  insertQueryOrderByExpressionInOrderByAt(
-    options: Partial<QueryOrderByExpression> | QueryOrderByExpression,
-    index: number,
-  ) {
-    const node = this._insertQueryOrderByExpressionInOrderByAt(options as any, index);
+  insertQueryOrderByExpressionAt(options: Partial<QueryOrderByExpression> | QueryOrderByExpression, index: number) {
+    const node = this._insertQueryOrderByExpressionAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -667,38 +651,34 @@ export class CallQueryComponent extends LogicItem {
    * @internal
    * @param queryOrderByExpressionOptions 查询排序子句参数
    */
-  _addQueryOrderByExpressionInOrderBy(
-    queryOrderByExpressionOptions: Partial<QueryOrderByExpression>,
-  ): QueryOrderByExpression;
+  _addQueryOrderByExpression(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>): QueryOrderByExpression;
 
   /**
    * 添加查询排序子句
    * @internal
    * @param queryOrderByExpression 已有的查询排序子句实例
    */
-  _addQueryOrderByExpressionInOrderBy(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
+  _addQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
 
-  _addQueryOrderByExpressionInOrderBy(options?: Partial<QueryOrderByExpression> | QueryOrderByExpression) {
+  _addQueryOrderByExpression(options?: Partial<QueryOrderByExpression> | QueryOrderByExpression) {
     const index = this.orderBy.length;
-    return this._insertQueryOrderByExpressionInOrderByAt(options as any, index);
+    return this._insertQueryOrderByExpressionAt(options as any, index);
   }
 
   /**
    * 添加查询排序子句
    * @param queryOrderByExpressionOptions 查询排序子句参数
    */
-  addQueryOrderByExpressionInOrderBy(
-    queryOrderByExpressionOptions: Partial<QueryOrderByExpression>,
-  ): QueryOrderByExpression;
+  addQueryOrderByExpression(queryOrderByExpressionOptions: Partial<QueryOrderByExpression>): QueryOrderByExpression;
 
   /**
    * 添加查询排序子句
    * @param queryOrderByExpression 已有的查询排序子句实例
    */
-  addQueryOrderByExpressionInOrderBy(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
+  addQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): QueryOrderByExpression;
 
-  addQueryOrderByExpressionInOrderBy(options?: Partial<QueryOrderByExpression> | QueryOrderByExpression) {
-    const node = this._addQueryOrderByExpressionInOrderBy(options as any);
+  addQueryOrderByExpression(options?: Partial<QueryOrderByExpression> | QueryOrderByExpression) {
+    const node = this._addQueryOrderByExpression(options as any);
     const index = this.orderBy.indexOf(node);
     node.create({
       index,
@@ -708,144 +688,24 @@ export class CallQueryComponent extends LogicItem {
     return node;
   }
 
-  /**
-   * 删除类型标注
-   * @param name 类型标注名称
-   */
-  removeTypeAnnotation(name: string): void;
-
-  /**
-   * 删除类型标注
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
-
-  removeTypeAnnotation(options: string | TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation;
-    if (typeof options === 'string') {
-      typeAnnotation = this.typeAnnotation;
-      if (!typeAnnotation) {
-        throw new Error('找不到类型标注 ' + options);
-      }
-    } else {
-      typeAnnotation = options;
-    }
-    return typeAnnotation.delete();
-  }
-
-  __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-    const parentKey = typeAnnotation.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: typeAnnotation,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = typeAnnotation.__v_raw || typeAnnotation;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
-  /**
-   * 删除查询选择子句
-   * @param name 查询选择子句名称
-   */
-  removeSelect(name: string): void;
-
-  /**
-   * 删除查询选择子句
-   * @param select 已有的查询选择子句实例
-   */
-  removeSelect(select: QuerySelectExpression): void;
-
-  removeSelect(options: string | QuerySelectExpression) {
-    let select: QuerySelectExpression;
-    if (typeof options === 'string') {
-      select = this.select;
-      if (!select) {
-        throw new Error('找不到查询选择子句 ' + options);
-      }
-    } else {
-      select = options;
-    }
-    return select.delete();
-  }
-
-  /**
-   * 删除查询 From 子句
-   * @param name 查询 From 子句名称
-   */
-  removeFrom(name: string): void;
-
-  /**
-   * 删除查询 From 子句
-   * @param from 已有的查询 From 子句实例
-   */
-  removeFrom(from: QueryFromExpression): void;
-
-  removeFrom(options: string | QueryFromExpression) {
-    let from: QueryFromExpression;
-    if (typeof options === 'string') {
-      from = this.from;
-      if (!from) {
-        throw new Error('找不到查询 From 子句 ' + options);
-      }
-    } else {
-      from = options;
-    }
-    return from.delete();
-  }
-
   /**
    * 删除逻辑项
-   * @param name 逻辑项名称
+   * @param logicItem 已有的逻辑项实例
    */
-  removeWhere(name: string): void;
+  removeItemInWherePlayground(logicItem: LogicItem): void;
 
-  /**
-   * 删除逻辑项
-   * @param where 已有的逻辑项实例
-   */
-  removeWhere(where: LogicItem): void;
-
-  removeWhere(options: string | LogicItem) {
-    let where: LogicItem;
-    if (typeof options === 'string') {
-      where = this.where;
-      if (!where) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      where = options;
-    }
-    return where.delete();
+  removeItemInWherePlayground(options: LogicItem) {
+    let logicItem: LogicItem = options;
+    return logicItem.delete();
   }
 
   /**
    * 删除逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  removeItemInWherePlayground(logicItem: LogicItem): void;
+  removeItemInHavingPlayground(logicItem: LogicItem): void;
 
-  removeItemInWherePlayground(options: LogicItem) {
+  removeItemInHavingPlayground(options: LogicItem) {
     let logicItem: LogicItem = options;
     return logicItem.delete();
   }
@@ -854,116 +714,24 @@ export class CallQueryComponent extends LogicItem {
    * 删除查询分组
    * @param queryGroupByExpression 已有的查询分组实例
    */
-  removeQueryGroupByExpressionInGroupBy(queryGroupByExpression: QueryGroupByExpression): void;
+  removeQueryGroupByExpression(queryGroupByExpression: QueryGroupByExpression): void;
 
-  removeQueryGroupByExpressionInGroupBy(options: QueryGroupByExpression) {
+  removeQueryGroupByExpression(options: QueryGroupByExpression) {
     let queryGroupByExpression: QueryGroupByExpression = options;
     return queryGroupByExpression.delete();
   }
 
-  /**
-   * 删除逻辑项
-   * @param name 逻辑项名称
-   */
-  removeHaving(name: string): void;
-
-  /**
-   * 删除逻辑项
-   * @param having 已有的逻辑项实例
-   */
-  removeHaving(having: LogicItem): void;
-
-  removeHaving(options: string | LogicItem) {
-    let having: LogicItem;
-    if (typeof options === 'string') {
-      having = this.having;
-      if (!having) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      having = options;
-    }
-    return having.delete();
-  }
-
-  /**
-   * 删除逻辑项
-   * @param logicItem 已有的逻辑项实例
-   */
-  removeItemInHavingPlayground(logicItem: LogicItem): void;
-
-  removeItemInHavingPlayground(options: LogicItem) {
-    let logicItem: LogicItem = options;
-    return logicItem.delete();
-  }
-
   /**
    * 删除查询排序子句
    * @param queryOrderByExpression 已有的查询排序子句实例
    */
-  removeQueryOrderByExpressionInOrderBy(queryOrderByExpression: QueryOrderByExpression): void;
+  removeQueryOrderByExpression(queryOrderByExpression: QueryOrderByExpression): void;
 
-  removeQueryOrderByExpressionInOrderBy(options: QueryOrderByExpression) {
+  removeQueryOrderByExpression(options: QueryOrderByExpression) {
     let queryOrderByExpression: QueryOrderByExpression = options;
     return queryOrderByExpression.delete();
   }
 
-  /**
-   * 删除查询分页子句
-   * @param name 查询分页子句名称
-   */
-  removeLimit(name: string): void;
-
-  /**
-   * 删除查询分页子句
-   * @param limit 已有的查询分页子句实例
-   */
-  removeLimit(limit: QueryLimitExpression): void;
-
-  removeLimit(options: string | QueryLimitExpression) {
-    let limit: QueryLimitExpression;
-    if (typeof options === 'string') {
-      limit = this.limit;
-      if (!limit) {
-        throw new Error('找不到查询分页子句 ' + options);
-      }
-    } else {
-      limit = options;
-    }
-    return limit.delete();
-  }
-
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
@@ -990,18 +758,19 @@ export class CallQueryComponent extends LogicItem {
       groupBy: [],
       having: null,
       orderBy: [],
-      limit: {
-        concept: 'QueryLimitExpression',
-        label: '查询组件Limit子句',
-        pageElement: {
-          concept: 'NumericLiteral',
-          value: 1,
-        },
-        pageSizeElement: {
-          concept: 'NumericLiteral',
-          value: 1000,
-        },
-      },
+      limit: null,
+      // limit: {
+      //   concept: 'QueryLimitExpression',
+      //   label: '查询组件Limit子句',
+      //   pageElement: {
+      //     concept: 'NumericLiteral',
+      //     value: 1,
+      //   },
+      //   pageSizeElement: {
+      //     concept: 'NumericLiteral',
+      //     value: 1000,
+      //   },
+      // },
     };
   }
 
@@ -1031,6 +800,32 @@ export class CallQueryComponent extends LogicItem {
     return code;
   }
 
+  entityNames() {
+    const entityNames = this.entityInfos.map(({ namespace, name }) => {
+      const namespaceArr = namespace?.split('.') || [];
+      const keywordDataSourceIndex = utils.findConceptKeyWordIndexFromNamespace(namespace, 'dataSources');
+      const dataSourceName = keywordDataSourceIndex !== -1 ? namespaceArr[keywordDataSourceIndex + 1] : '';
+      const names = [name];
+      if (dataSourceName) {
+        names.unshift(dataSourceName);
+      }
+      return names.join('.');
+    });
+    const lines = [];
+    const fontCount = 60;
+    const entityNamesStr = entityNames.join(',') || '-';
+    for (let i = 0; i < entityNamesStr.length; i += fontCount) {
+      lines.push(entityNamesStr.slice(i, i + fontCount));
+    }
+    return lines;
+  }
+
+  toUI(state?: TranslatorState, hideDetails?: boolean): string {
+    let code = '';
+    code += `数据查询（数据源：${this.entityNames()}）`;
+    return code;
+  }
+
   toJS() {
     return '';
     // const { entityName } = this.from;
@@ -1105,15 +900,9 @@ export class CallQueryComponent extends LogicItem {
       state,
       multipleErrorType: '__WHERE_MULTIPLE_CONDITION__',
     });
-    if (self.select.selectAggregateElements.length) {
-      // 聚合属性
-      code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectAggregateElements, {
-        code,
-        state,
-      });
-    } else {
-      // select实体字段
-      code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectFieldElements, {
+    // 聚合属性 & select实体字段
+    if (self.select.selectElements.length) {
+      code = yield* self.toEmbeddedTSOfSubPart('SELECT', self.select.selectElements, {
         code,
         state,
       });
@@ -1134,11 +923,6 @@ export class CallQueryComponent extends LogicItem {
       code,
       state,
     });
-    // 分页参数
-    code = yield* self.toEmbeddedTSOfSubPart('LIMIT', self.limit ? [self.limit] : [], {
-      code,
-      state,
-    });
     code += '\n';
     code += `${indent((state?.tabSize || 0) + 1)}return;\n`;
     code += `${indent(state?.tabSize || 0)}})()`;
@@ -1358,7 +1142,7 @@ export class CallQueryComponent extends LogicItem {
     // 1. 有分组
     if (groupByLength) {
       if (!aggregateLength && groupByLength === 1) {
-        // 1.1 单分组无聚合：`{ list: List<列的类型>, total: Long }`
+        // 1.1 单分组无聚合：`List<列的类型>`
         const { entityAsName, propertyName } = groupBy[0].groupElement as QueryFieldExpression;
         const entity = entities.find((item: Entity) => item.name === entityAsName);
         const property = entity?.properties.find((item: any) => item.name === propertyName);
@@ -1367,41 +1151,15 @@ export class CallQueryComponent extends LogicItem {
         typeAnnotation = TypeAnnotation.from(
           {
             concept: 'TypeAnnotation',
-            typeKind: 'anonymousStructure',
-            properties: [
-              StructureProperty.from({
-                name: 'list',
-                typeAnnotation: TypeAnnotation.from(
-                  {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'generic',
-                    typeName: 'List',
-                    typeNamespace: 'nasl.collection',
-                    typeArguments: [
-                      TypeAnnotation.from({
-                        concept: propertyTypeAnnotation.concept,
-                        typeKind: propertyTypeAnnotation.typeKind,
-                        typeName: propertyTypeAnnotation.typeName,
-                        typeNamespace: propertyTypeAnnotation.typeNamespace,
-                      }),
-                    ],
-                  },
-                  this.typeAnnotation,
-                  'typeAnnotation',
-                ),
-              }),
-              StructureProperty.from({
-                name: 'total',
-                typeAnnotation: TypeAnnotation.from(
-                  {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'primitive',
-                    typeNamespace: 'nasl.core',
-                    typeName: 'Long',
-                  },
-                  this.typeAnnotation,
-                  'typeAnnotation',
-                ),
+            typeKind: 'generic',
+            typeName: 'List',
+            typeNamespace: 'nasl.collection',
+            typeArguments: [
+              TypeAnnotation.from({
+                concept: propertyTypeAnnotation.concept,
+                typeKind: propertyTypeAnnotation.typeKind,
+                typeName: propertyTypeAnnotation.typeName,
+                typeNamespace: propertyTypeAnnotation.typeNamespace,
               }),
             ],
           },
@@ -1409,47 +1167,21 @@ export class CallQueryComponent extends LogicItem {
           'typeAnnotation',
         );
       } else {
-        // 1.2 多分组：`{ list: List<anonymousStructure>, total: Long }`
+        // 1.2 多分组：`List<anonymousStructure>`
         typeAnnotation = TypeAnnotation.from(
           {
             concept: 'TypeAnnotation',
-            typeKind: 'anonymousStructure',
-            properties: [
-              StructureProperty.from({
-                name: 'list',
-                typeAnnotation: TypeAnnotation.from(
-                  {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'generic',
-                    typeName: 'List',
-                    typeNamespace: 'nasl.collection',
-                    typeArguments: [
-                      TypeAnnotation.from({
-                        concept: 'TypeAnnotation',
-                        typeKind: 'anonymousStructure',
-                        properties: [
-                          ...this.genPropertyListOfGroupBy(this, entities),
-                          ...this.genPropertyListOfAggregate(this, entities),
-                        ],
-                      }),
-                    ],
-                  },
-                  this.typeAnnotation,
-                  'typeAnnotation',
-                ),
-              }),
-              StructureProperty.from({
-                name: 'total',
-                typeAnnotation: TypeAnnotation.from(
-                  {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'primitive',
-                    typeNamespace: 'nasl.core',
-                    typeName: 'Long',
-                  },
-                  this.typeAnnotation,
-                  'typeAnnotation',
-                ),
+            typeKind: 'generic',
+            typeName: 'List',
+            typeNamespace: 'nasl.collection',
+            typeArguments: [
+              TypeAnnotation.from({
+                concept: 'TypeAnnotation',
+                typeKind: 'anonymousStructure',
+                properties: [
+                  ...this.genPropertyListOfGroupBy(this, entities),
+                  ...this.genPropertyListOfAggregate(this, entities),
+                ],
               }),
             ],
           },
@@ -1506,44 +1238,18 @@ export class CallQueryComponent extends LogicItem {
           );
         }
       } else {
-        // 2.3 无分组&&无聚合 (默认情况)：`{ list: List<Structure>, total: Long }`
+        // 2.3 无分组&&无聚合 (默认情况)：`List<Structure>`
         typeAnnotation = TypeAnnotation.from(
           {
             concept: 'TypeAnnotation',
-            typeKind: 'anonymousStructure',
-            properties: [
-              StructureProperty.from({
-                name: 'list',
-                typeAnnotation: TypeAnnotation.from(
-                  {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'generic',
-                    typeName: 'List',
-                    typeNamespace: 'nasl.collection',
-                    typeArguments: [
-                      TypeAnnotation.from({
-                        concept: 'TypeAnnotation',
-                        typeKind: 'anonymousStructure',
-                        properties: this.genPropertiesFrom(this.from),
-                      }),
-                    ],
-                  },
-                  this.typeAnnotation,
-                  'typeAnnotation',
-                ),
-              }),
-              StructureProperty.from({
-                name: 'total',
-                typeAnnotation: TypeAnnotation.from(
-                  {
-                    concept: 'TypeAnnotation',
-                    typeKind: 'primitive',
-                    typeNamespace: 'nasl.core',
-                    typeName: 'Long',
-                  },
-                  this.typeAnnotation,
-                  'typeAnnotation',
-                ),
+            typeKind: 'generic',
+            typeName: 'List',
+            typeNamespace: 'nasl.collection',
+            typeArguments: [
+              TypeAnnotation.from({
+                concept: 'TypeAnnotation',
+                typeKind: 'anonymousStructure',
+                properties: this.genPropertiesFrom(this.from),
               }),
             ],
           },
@@ -1771,7 +1477,7 @@ export class CallQueryComponent extends LogicItem {
   // 将所有from的实体，在selectElements中初始化一个isDotStar=true的QueryFieldExpression
   initFieldSelectElement(node: CallQueryComponent = this) {
     const loop = (from: QueryFromExpression | QueryJoinExpression) => {
-      node.select.addQueryFieldExpressionInSelectElements({
+      node.select.addQueryFieldExpression({
         entityAsName: from.entityName,
         isDotStar: true,
       });