QL语言参考-3类型
类型（Types）
QL 是一种静态类型的语言，因此每个变量都必须有一个声明的类型。
类型是一组值。例如，int 类型是一组整数。注意，一个值可以属于这些集合中的多个，这意味着它可以有多个类型。
QL 中的类型有基本类型、类、字符类型、类域类型、代数数据类型、类型联合和数据库类型。primitive types, classes, character types, class domain types, algebraic datatypes, type unions, and database types.
基本类型(Primitive types)
这些类型是构建在 QL 中的，并且总是在全局名称空间中可用，与要查询的数据库（就是需要审查的项目生成的AST数据库），也就是说基本类型与项目无关。
- 布尔类型boolean：此类型包含true和false值。
- 浮点类型float：这种类型包含64位浮点数，例如6.28和-0.618。
- 整数类型int：这种类型包含32位2的补码整数，例如-1和42。
- 字符串string：这种类型包含16位字符的有限字符串。
- 日期date：此类型包含日期（以及可选的时间）。
QL 有一系列基本类型上定义的内置操作。可以通过对适当类型的表达式使用 dispatch 来实现这些功能。
例如，1.toString ()是整数常量1的字符串表示形式。有关 QL 中可用的内置操作的完整列表，请参阅 QL 语言规范中关于内置操作 的部分。
类（Classes）
可以在 QL 中定义自己的类型。
类提供了一种简单的方法来重用和构造代码。例如，你可以:
- 将相关的值分组
- 在这些值上定义成员谓词
- 重写成员谓词的子类
注意：QL 中的类并不“创建”一个新对象，它只是表示一个逻辑属性。如果值满足该逻辑属性，则该值属于特定类。
定义类
要定义一个类，可以这样写:
-
使用class关键字
-
指定类的名字，类名的首字母用大写
-
指定继承的type
-
类的body部分
class OneTwoThree extends int {
OneTwoThree() { // characteristic predicate 特征谓词
this = 1 or this = 2 or this = 3
}
string getAString() { // member predicate 成员谓词
result = "One, two or three: " + this.toString()
}
predicate isEven() { // member predicate 成员谓词
this = 2
}
}
这定义了一个类 OneTwoThree，其中包含值1、2和3。特征谓词捕获“作为整数1、2或3之一”的逻辑属性
OneTwoThree 扩展 int，也就是说，它是 int 的一个子类型。
注意：QL 中的类必须总是至少有一个超类型。使用 extends 关键字引用的超类型称为类的基类型。类的值包含在超类型的交集中(也就是说，它们在类域类型中)。类从其基类型继承所有成员谓词。
一个类可以扩展多种类型。有关更多信息，请参阅《多重继承类》，类也可以专门化其他类型，而不需要通过 instanceof 扩展类接口，参见“非扩展子类型”.
有效的一个类:
- Must not extend itself. 不能继承扩展自己
- Must not extend a final class. 不能继承与final类
- Must not extend types that are incompatible. For more information, see “Type compatibility.” 不能继承不兼容的类型。
您还可以对一个类进行注释。请参阅可用于类的注释列表。
Class bodies
类的主体可以包含：
- 特征谓词（构造函数）的声明。
- 任意数量的成员谓词（成员函数）声明。
- 任意数量的字段声明（成员变量）。
定义类时，该类还从其超类型继承所有非私有成员谓词和字段。您可以重写这些谓词和字段，以给出更具体的定义。
特征谓词（Characteristic predicates）
这些谓词是在类体内定义的。它们是逻辑属性，使用变量 this 限制类中的可能值。
成员谓词(Member predicates)
这些谓词只适用于特定类的成员。可以对值调用成员谓词。例如，你可以使用上面类中的成员谓词:
1.(OneTwoThree).getAString()
这个调用返回结果“ One，two or three: 1”。
表达式(OneTwoThree)是一个强制转换。它确保1的类型是 OneTwoThree 而不是 int。因此，它可以访问成员谓词 getAString ()。
成员谓词特别有用，因为您可以将它们链接在一起。例如，你可以使用 toUpperCase () ，一个为字符串定义的内置函数:
1.(OneTwoThree).getAString().toUpperCase()
这个调用返回 "ONE, TWO OR THREE: 1".
注意
特征谓词和成员谓词通常使用 this 变量。这个变量总是引用类的一个成员，在这种情况下，这个值属于类 OneTwoThree。在特征谓词中，这个变量约束类中的值。在成员谓词中，这与谓词的任何其他参数的行为方式相同。
字段（Fields）
类似成员变量。这些是在类体中声明的变量。一个类可以在其主体中包含任意数量的字段声明(即变量声明)。您可以在类内的谓词声明中使用这些变量。与变量 this 非常相似，字段必须在特征谓词中进行约束。
class SmallInt extends int {
SmallInt() { this = [1 .. 10] }
}
class DivisibleInt extends SmallInt {
SmallInt divisor; // declaration of the field `divisor` 成员变量
DivisibleInt() { this % divisor = 0 }
SmallInt getADivisor() { result = divisor }
}
from DivisibleInt i
select i, i.getADivisor()
在这个例子中，声明 SmallInt 因子引入了一个字段因子，在特征谓词中约束它，然后在成员谓词 getadavors 的声明中使用它。这类似于通过在 from 部分中声明变量来在 select 子句中引入变量。
具体类（Concrete classes）
上面例子中的类都是具体的类。具体类表示的数值集合是：满足该类特征谓词的数值集合与base type表示的数值集合的交集。
抽象类（Abstract classes）
可以使用abstrace关键字来标注一个类是抽象类。
抽象类表示的数值集合是：满足该类特征谓词的数值集合与所有子类表示的数值集合的并集。
如下是内置库中QueryInjection.ql中定义的QueryInjectionSink抽象类
如果您正在编写一个安全查询，您可能对识别所有可以解释为 SQL 查询的表达式感兴趣。你可以使用下面的抽象类来描述这些表达式:
abstract class SqlExpr extends Expr {
...
}
注意：在向现有抽象类添加新子类时，必须小心。添加子类并不是一个孤立的变更，它还扩展了抽象类，因为这是它的子类的一个联合。
重写成员谓词
如果类从超类型继承成员谓词，则可以重写继承的定义。使用override关键词
class OneTwo extends OneTwoThree {
OneTwo() {
this = 1 or this = 2
}
override string getAString() {
result = "One or two: " + this.toString()
}
}
成员谓词 getAString ()覆盖了来自 OneTwoThree 的 getAString ()的原始定义。
现在，考虑下面的查询:
from OneTwoThree o
select o, o.getAString()
| # | o | [1] |
|---|---|---|
| 1 | 1 | One or two: 1 |
| 2 | 2 | One or two: 2 |
| 3 | 3 | One, two or three: 3 |
注意：在 QL 中，与其他面向对象语言不同，相同类型的不同子类型不需要分离。
例如，你可以定义 OneTwoThree 的另一个子类，它与 OneTwo 重叠:
class TwoThree extends OneTwoThree {
TwoThree() {
this = 2 or this = 3
}
override string getAString() {
result = "Two or three: " + this.toString()
}
}
| # | o | [1] |
|---|---|---|
| 1 | 1 | One or two: 1 |
| 2 | 2 | One or two: 2 |
| 3 | 2 | Two or three: 2 |
| 4 | 3 | Two or three: 3 |
class OneTwoThree extends int {
OneTwoThree() { // characteristic predicate 特征谓词
this = 1 or this = 2 or this = 3
}
string getAString() { // member predicate 成员谓词
result = "One, two or three: " + this.toString()
}
predicate isEven() { // member predicate 成员谓词
this = 2
}
}
class OneTwo extends OneTwoThree {
OneTwo() {
this = 1 or this = 2
}
override string getAString() {
result = "One or two: " + this.toString()
}
}
class TwoThree extends OneTwoThree {
TwoThree() {
this = 2 or this = 3
}
override string getAString() {
result = "Two or three: " + this.toString()
}
}
from OneTwoThree o
select o, o.getAString()
多重继承
一个类可以扩展多个类型。在这种情况下，它继承自所有这些类型。
例如，使用上面一节中的定义:
class Two extends OneTwo, TwoThree {}
第二类中的任何值都必须满足 OneTwo 表示的逻辑属性和 TwoThree 表示的逻辑属性。在这里，类Tow包含一个值，即2。
它继承了 OneTwo 和 TwoThree 的成员谓词，也(间接地)继承了 OneTwoThree 和 int。
注意：如果子类继承同一谓词名称的多个定义，则必须重写这些定义以避免歧义。超级表达式在这种情况下常常很有用。
不扩展的子类型
使用关键词instantof
Non-extending subtypes
除了扩展基类型之外，类还可以声明与其他类型的实时关系。将一个类声明为 Foo 的 instanceof，大致等同于在特征谓词中声明 Foo 的 instanceof。主要的区别是，你可以通过超级调用 Bar 上的方法，你可以得到更好的优化。
class Foo extends int {
Foo() { this in [1 .. 10] }
string foo_method() { result = "foo" }
}
class Bar instanceof Foo {
string toString() { result = super.foo_method() }
}
在这个例子中，Foo 的特征谓词也应用于 Bar。但是，foo_method 没有在 Bar 中公开，因此查询任何any(Bar b).foo_method() 会导致编译时错误。从示例中注意，仍然可以从带有 super 关键字的专门化类中的 instanceof 超类型访问方法。
关键的是，超类型的 instanceof 不是基类型。这意味着这些超类型不参与重写，而且这些超类型的任何字段都不是新类的一部分。当涉及到复杂的类层次结构时，这对方法解析有影响。下面的示例演示了这一点。
class Interface extends int {
Interface() { this in [1 .. 10] }
string foo() { result = "" }
}
class Foo extends int {
Foo() { this in [1 .. 5] }
string foo() { result = "foo" }
}
class Bar extends Interface instanceof Foo {
override string foo() { result = "bar" }
}
在这里，方法 Bar::Foo 不会覆盖 Foo::Foo。相反，它只覆盖 Interface::foo。这意味着选择任意(Foo f).Foo ()只产生 foo。如果 Bar 被定义为 extends Foo，那么选择 any (Foo b)就会产生 bar。
