数据库

导入

通过如下方式导入数据库api

import db from 'svr-api/db';
//获取默认数据源对象
let ds = db.getDefaultDataSource();

方法

/**
 * 数据库相关API
 */

/**
 * 获取系统中所有数据源的名称。
 * 
 * @returns 返回一个字符串数组
 */
export function getDataSources(): Array<string>;

/**
 * 获取默认数据源，默认数据源用于存储系统的元数据、日志等内容
 * 
 * @returns 返回默认数据源
 */
export function getDefaultDataSource(): Datasource;

/**
 * 获取指定的数据源
 * 
 * @param name 要获取的数据源的名称
 * @param throwIfNotExist 如果不存在是否抛出异常，默认false
 * 
 * @returns 不存在时返回null
 */
export function getDataSource(name: string, throwIfNotExist?: boolean): Datasource;

/**
 * 获取一个序列号产生器。确保能产生集群唯一的序列号。
 * 
 * @param namespace 序列号的命名空间。
 */
export function getNumberSequencer(namespace: string): NumberSequencer;

/**
 * 获取redis客户端。
 * @param serviceName 服务名，为空时获取默认的
 * https://github.com/redisson/redisson
 */
export function getRedisClient(serviceName?: string): Redis;

/**
 * 建立一个新的数据库连接。
 * 
 * !!!WARNING!!!: 
 * 
 * 1. 此函数每次都会发起新的数据库连接，不会使用连接池，存在性能隐患，请谨慎使用。
 * 2. 返回的连接不使用时必须关闭。
 * 
 * @param jdbcConf 数据库连接的配置。
 */
export function openConnection(jdbcConf: JdbcConfigInfo): Connection;

/**
 * 将一个标识符路径（“qualified name”）按点号拆分成一个数组。
 *
 * 关于“qualified name”，见函数{@link Dialect#getDefaultQualifiedSchema()}的注释说明。
 *
 * 返回值：
 *
 * 倒序的，数组的长度可能是2为或更长，如对于表`catalog1.schema1.table1`，此属性是
 * `["table1","schema1","catalog1"]`，注意数组中不会存在空值，例如，schema是默认的，那么会是当前
 * schema的名字，如果db不支持schema，那么数组中不会有schema。
 *
 * @see Dialect#getDefaultQualifiedSchema()
 *
 * @param qualifiedName 传入完整表名路径或schema路径，如`catalog.schema.table`，可为空，此时返回
 *        null
 * @return 返回拆分后的数组，传入null时返回null。
 */
export function splitQualifiedName(qualifiedName: string): string[];

/**
 * 将一个命名空间数组，转换为一个完整的`fully-qualified name`。
 * 
 * 是{@link #splitQualifiedName(String)}的逆操作。
 * `["table1","schema1","catalog1"]`返回`catalog1.schema1.table1`
 * 
 * @param qualifiedNames 
 */
export function concatQualifiedName(...qualifiedNames: string[]): string;

/**
 * 创建一个数据迁移工具（`com.succez.commons.jdbc.migrate.MigrateData`）。
 * 
 * 使用完毕后必须调用{@link MigrateData#close()}释放资源。
 * 
 * @param threadPoolSize 不传递或传递null，将创建没有线程池的对象，否则创建指定最大线程个数的对象。
 */
export function createMigrateData(threadPoolSize?: number): any;

对象

/**
 * 数据源对象，通过此对象可以获取数据源相关属性、执行SQL。
 */
declare interface Datasource {
	/**
	 * 返回数据源的名称
	 */
	getName(): string;

	/**
	 * 返回当前数据源的状态。
	 */
	getState(): DataSourceState;

	/**
	 * 检查连接池可用。
	 *
	 * 最初连接池建立时，连接池的状态是{@link DataSourceState#READY}，此时不一定可连接，此时此函数会
	 * 尝试进行一次db连接以判断连接性，可能会等待一段时间。
	 * 
	 * @param throwIfCannt 如果不能连接，是否抛出异常，默认false。
	 * @return
	 */
	checkConnectable(throwIfCannt?: boolean): boolean;

	/**
	 * 返回Jdbc配置。
	 */
	getJdbcConf(): JdbcConfigInfo;

	/**
	 * 后端的Dialect.java对象，可以访问一些数据库相关方言配置信息。
	 */
	getDialect(): DbDialect | any;

	/**
	 * 后端的DbMetaUtils.java对象。
	 */
	getMetaUtils(conn?: Connection): any;

	/**
	 * 获取默认schema（即{@link getConnection()}函数返回的连接的默认的Schema）。
	 */
	getDefaultSchema(): string;

	/**
	 * 获取schema列表。
	 * 
	 * @return 不存在时返回空数组。
	 */
	getSchemas(catalog?: string): Array<string>;

	/**
	 * 获取表列表。
	 *
	 * 这个表列表是广义上的，包括所有对象：物理表、视图、同义词、物化视图等。
	 *
	 * @param readComments 是否同时查询表的描述信息，有些数据库查询表描述性能比较低，默认false。
	 * @param schema 传递null表示使用当前默认的schema，大小写是否敏感依赖具体数据库的实现，支持传递
	 *      中括号转义后的内容。
	 * @return 不存在时返回空数组
	 */
	getTables(readComments?: boolean, schema?: string): Array<TableMetaData>;

	/**
	 * 执行一个查询，并返回第一行数据的json（如果只是一个字段的话，直接返回字段的值）。
	 *
	 * 1. 为了性能考虑，调用者应该自己在sql语句中添加合适的条件或者limit语句，确保结果最多只返回一
	 *    行，如果sql返回的结果很大，可能在某些数据库如mysql上出现内存溢出问题。
	 * 2. Clob字段会当做字符串返回。
	 * 3. Blob字段会当做byte数组返回，如果Blob字段的内容可能很大，比如几十、几百Mb，那么不推荐使用此
	 *    函数，建议直接使用{@link getConnection()}函数操作原始的jdbc API接口读取。
	 *
	 * @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的
	 *     问号会用`params`中对应的值替换
	 * @param params 可选，sql中需要的参数值
	 * @returns 如果是多个字段那么返回一个json对象，key是字段名，当数据不存在时返回`null`，只是一个
	 *     字段时，返回的结果就是字段值
	 */
	selectFirst(sql: string, ...params: any): { [fieldName: string]: any } | any;

	/**
	 * 返回查询sql的数据行数
	 *
	 * @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable
	 *     where id＝?` ，其中的问号会用`params`中对应的值替换
	 * @param params 可选，sql中需要的参数值
	 * @returns 本次查询sql返回的结果行数
	 */
	getTotalCount(sql: string, ...params: any): number;

	/**
	 * 执行查询sql并返回查询结果，一个json数组。
	 *
	 * 1. 为了性能考虑，调用者应该自己在sql语句中添加合适的条件或者limit语句，确保结果最多只返回少量
	 *    的数据，如果sql返回的结果很大，可能在某些数据库如mysql上出现内存溢出问题。
	 * 2. Clob字段会当做字符串返回。
	 * 3. Blob字段会当做byte数组返回，如果Blob字段的内容可能很大，比如几十、几百Mb，那么不推荐使用此
	 *    函数，建议直接使用{@link getConnection()}函数操作原始的jdbc API接口读取。
	 *
	 * @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的
	 *     问号会用`params`中对应的值替换
	 * @param params 可选，sql中需要的参数值
	 * @returns 查询结果是数组的形式，无结果时返回空数组，每个元素是一个json，通过字段名获取字段的数
	 *  据
	 */
	executeQuery(sql: string, ...params: any): Array<{ [fieldName: string]: any }>;

	/**
	 * 执行查询sql并返回查询结果，一个二维数组。
	 *
	 * 1. 为了性能考虑，调用者应该自己在sql语句中添加合适的条件或者limit语句，确保结果最多只返回少量
	 *    的数据，如果sql返回的结果很大，可能在某些数据库如mysql上出现内存溢出问题。
	 * 2. Clob字段会当做字符串返回。
	 * 3. Blob字段会当做byte数组返回，如果Blob字段的内容可能很大，比如几十、几百Mb，那么不推荐使用此
	 *    函数，建议直接使用{@link getConnection()}函数操作原始的jdbc API接口读取。
	 *
	 * @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable
	 *     where id＝?` ，其中的问号会用`params`中对应的值替换
	 * @param params 可选，sql中需要的参数值
	 * @returns 查询结果是二维数组的形式，无结果时返回空数组
	 */
	executeQueryRows(sql: string, ...params: any): Array<Array<any>>;

	/**
	 * 将数据库表或是查询结果导出为csv|csz|xlsx文件
	 * 
	 * 如：`exportData({table: "DIM_BBQ",file: "/succez/exp"})`
	 */
	exportData(args: {
		/**要导出的表名称 */
		tableName?: string,
		/**表所在的schema */
		schema?: string,
		/**如果没有指定表，那么必须指定sql */
		sql?: string,
		/**sql中的参数 */
		sqlParams?: Array<any>,
		/**导出到哪个文件，可以传递目标文件路径或文件对象 */
		file: any,
		/**文件格式，为空时自动从文件名中分析 */
		fileFormat?: FileType,
		/**文件分隔符，默认逗号 */
		columnDelimiter?: string,
		/**文件编码，默认utf-8 */
		encoding?: string,
		/**
		 * 文件的时间戳字段的格式
		 *
		 * 与日期显示格式一致，使用excel风格的格式串，默认为`yyyy-mm-dd`
		 */
		dateFormat?: string,
		/**
		 * 文件的时间戳字段的格式
		 *
		 * 与日期显示格式一致，使用excel风格的格式串，默认为`yyyy-mm-dd hh:mm:ss.000`
		 */
		timestampFormat?: string,
		/**
		 * 首行是否为列头，若此参数为`false`时，只有数据，不含列头
		 *
		 * 默认为`true`。
		 */
		firstRowIsColumnName?: boolean,
		/**
		 * 首行格式，可能为以下值：
		 *
		 * 1. metaInfo 元数据完整信息
		 * 2. columnName 逻辑字段名，不存在时使用物理字段名
		 * 3. dbField 物理字段名
		 *
		 * 默认取`metaInfo`
		 */
		firstRowMetaFormat?: string
	}): void;

	/**
	 * 将csv|csz|xls|xlxs|dbf|szdb数据文件导入数据库表中
	 *
	 * @returns 返回导入后的返回信息，比如导入多少行、耗时多少等
	 */
	importData(args: {
		/**要导入数据的表名称 */
		tableName: string,
		/**表所在的schema */
		schema?: string,
		/**
		 * 要导入的文件，可为文件对象、路径名或输入流
		 *
		 * 暂不支持输入流导入DBF文件
		 */
		file: any,
		/**文件格式，默认为CSV文件 */
		fileFormat?: FileType,
		/** 导入模式，默认{@link DataImportMode.CLEARTABLE}，表示清空目标表后导入新的数据 */
		dataImportMode?: DataImportMode;
		/**文件分隔符，默认逗号 */
		columnDelimiter?: string,
		/**文件编码，默认utf-8 */
		encoding?: string,
		/**
		 * 文件的时间戳字段的格式
		 *
		 * 与日期显示格式一致，使用excel风格的格式串，默认为`yyyy-mm-dd`
		 */
		dateFormat?: string,
		/**
		 * 文件的时间戳字段的格式
		 *
		 * 与日期显示格式一致，使用excel风格的格式串，默认为`yyyy-mm-dd hh:mm:ss.000`
		 */
		timestampFormat?: string,
		/**
		 * 首行是否为列头，若此参数为`false`时，只有数据，不含列头
		 *
		 * 默认为`true`。
		 */
		firstRowIsColumnName?: boolean,
		/**
		 * 首行格式
		 *
		 * 可能为以下值：
		 * 	1. metaInfo 元数据完整信息
		 * 	2. columnName 逻辑字段名，不存在时使用物理字段名
		 * 	3. dbField 物理字段名
		 *
		 * 默认取`metaInfo`
		 */
		firstRowMetaFormat?: string
	}): {
		/** 返回导入的表名 */
		importTable: string;
		/** 返回导入总行数 */
		importRowCount: number;
		/** 返回忽略行 */
		rejectsRows: Array<number>;
		/** 导入耗时，单位毫秒 */
		totalTime: number;
		/** 返回执行的sql */
		sql: string;
	};

	/**
	 * 执行一个update或ddl语句，返回影响的行数
	 *
	 * @param sql update或ddl语句
	 * @param params 可选，sql中需要的参数值
	 * @returns 返回影响的行数
	 */
	executeUpdate(sql: string, ...params: any): number;

	/**
	 * 执行一个存储过程，如果存储过程有输出参数，则本函数会有返回值，返回值是一
	 * 个Map
	 *
	 * @param procName 存储过程的名称，如 “myproc”
	 * @param params 存储过程的参数，支持2种格式：
	 * 1. Object数组，比如 `[123,"def"]`。这种适用于执行没有输出参数的存储过程。
	 *    eg：插入一条数据到表中，调用`callproc(myproc, [123, "def"])`。内部将执
	 *    行sql——`myproc(123, 'def')`
	 * 2. JSON数组，数组中的每个元素代表存储过程的一个参数，格式：`[{name: "参数
	 *    名称", value: "参数值", type: "参数值的类型", isOutput: true}]`，这种
	 *    适用于执行有输出参数的存储过程。
	 *
	 * 说明：
	 * 1. name是参数名称，比如："salary"
	 * 2. value是参数的值，比如：3000。如果不指定，则为null
	 * 3. type是参数的值的类型，目前支持的类型有"string"、"number"。如果不指定，
	 *    则默认为"string"
	 * 4. isOutput是表示参数是否时输出参数。存储过程比较奇怪，调用的时候必须指出
	 *    有哪些输出参数。如果不指定，则默认为false，表示不是输出参数（即为输入
	 *    参数。 eg：查询薪水3000以上的人员的数量,调用`callproc("calcSalary",
	 *    [{name: "salary", value: 3000}, {name: "count",type:
	 *    "number",isOutput: true}] )`;调用之后函数返回一个Map，比如：`{count:
	 *    150}`
	 */
	callproc(
		procName: string,
		params?: JSONObject[] | Array<{ value: any, name?: string, type?: "number" | "string", isOutput?: boolean }>
	): { [outputParam: string]: any };

	/**
	 * 创建一个物理表。
	 * 
	 * 当表已存在时会抛异常。
	 */
	createTable(tableInfo: TableMetaInfo): void;

	/**
	 * 修改一个物理表。
	 * 
	 * 当表不存在时会抛异常。
	 */
	alterTable(tableInfo: TableMetaInfo): void;

	/**
	 * 返回一个负责创建和修改表结构的工具类。
	 */
	createTableDDLExecutor(tableInfo: TableMetaInfo): TableMetaDDLExecutor;

	/**
	 * 返回一个SQL构造器。便于基于API接口的形式构造DML、SQL语句，构造的语句能自动适配相关数据库的语法要求。
	 */
	createSQLBuilder(): any;

	/**
	 * 判断表或视图是否存在
	 *
	 * @param tableName 表名或视图名
	 * @param schema 可选，schema名称
	 */
	isTableExists(tableName: string, schema?: string): boolean;

	/**
	 * 返回数据源的元数据信息
	 */
	getMetaData(): DatasourceMetaData;

	/**
	 * 返回表或视图的元数据信息
	 *
	 * @param tableName 表名或视图名
	 * @param schema 可选，schema名称
	 */
	getTableMetaData(tableName: string, schema?: string): TableMetaData;

	/**
	 * 返回一个能方便的对一个表进行查询或数据更新的工具对象。
	 * 
	 * 调用者需要自己关闭返回的对象。
	 *
	 * @param tableName 表名或视图名
	 * @param schema 可选，schema名称
	 * @param conn 可选，Connection对象
	 */
	openTableData(tableName: string, schema?: string, conn?: Connection): TableData;

	/**
	 * 删除一张表，要删除的表必须存在。
	 *
	 * @param tableName 表名
	 * @param schema 可选，schema名称
	 */
	dropTable(tableName: string, schema?: string): void;

	/**
	 * 删除一张表，如果不存在则什么都不做。
	 *
	 * @param tableName 表名
	 * @param schema 可选，schema名称
	 */
	dropTableIfExists(tableName: string, schema?: string): void;

	/**
	 * 删除视图。
	 *
	 *
	 * @param name 视图名
	 * @param schema 可选，schema名称
	 */
	dropView(name: string, schema?: string): void;

	/**
	 * 删除视图。
	 * 
	 * 如果不存在，忽略异常。
	 *
	 * @param name 视图名
	 * @param schema 可选，schema名称
	 */
	dropViewIfExists(name: string, schema?: string): void;

	/**
	 * 表更名。
	 *
	 * 两个表名参数必需是同一个schema下的表；
	 *
	 * @param oldName 原始标识符，通常是逻辑层模型（即元数据的tbl文件）中记录的用户原始输入的内容。
	 *      支持传递中括号转义后的内容，此时将准确的按照数据库需要的大小写去查找对象。
	 * @param newName 新表名，不用带schema
	 * @param schema 传递null表示使用当前默认的schema，大小写是否敏感依赖具体数据库的实现，支持传递
	 *      中括号转义后的内容。
	 */
	renameTable(oldName: string, newName: string, schema?: string): void;

	/**
	 * truncate表数据，不能回滚。
	 *
	 * @param tableName 表名
	 * @param schema 可选，schema名称
	 */
	truncateTable(tableName: string, schema?: string): void;

	/**
	 * trancate表数据，同时重置自增长序列。
	 *
	 * @param tableName 表名
	 * @param schema 可选，schema名称
	 */
	truncateTableAndRestartSequence(tableName: string, schema?: string): void;

	/**
	 * 修改表注释
	 * 
	 * @param name 表名，不带schema
	 * @param schema 传递null表示使用当前默认的，或传入一个Qualified Schema Name，关于“qualified
	 *         name”，见函数{@link DbSQLTemplates.qualifiedTableName}的注释说明。
	 * @param comment 表注释，可以为null。
	 */
	setTableComment(name: string, schema: string, comment: string): void;

	/**
	 * 返回jdbc连接，连续多次调用此函数总是返回同一个连接对象，调用者需要负责关
	 * 闭获取的连接对象。
	 */
	getConnection(): Connection;

	/**
	 * 通常应用层不应该直接调用连接的{@link Connection.setCatalog(String)}或
	 * {@link Connection.setSchema(String)}函数，应该使用此函数来进行设置。
	 *
	 * 用于比如有些数据库创建表的时候必须切换到要创建表所在的schema，事后还要还原。
	 * 
	 * @see #getQualifiedSchema(Connection)
	 * @param conn 
	 * @param qualifiedSchema 
	 */
	ensureSchema(conn: Connection, qualifiedSchema: string): string;

	/**
	 * 返回当前的schema的完整路径（“fully-qualified name”）。
	 *
	 * 关于“fully-qualified name”，见{@link DbSQLTemplates.qualifiedTableName}函数的解释。
	 *
	 * 通常应用层不应该直接调用连接的{@link Connection.getCatalog()}或{@link Connection.getSchema()}
	 * 函数，应该使用此函数来获取一个“qualified name”。
	 * @param conn 
	 */
	getQualifiedSchema(conn: Connection): string;

	/**
	 * SQL字符串转义，防止SQL注入漏洞
	 *
	 * 脚本里面使用字符串拼sql，用户输入值要用escapeSQL转义之后再拼到SQL
	 * 里面去
	 *
	 * 比如： "field like '"+ds.escapeSQL(value)+"'" "insert into testtb
	 *      (field1,field2)value('aa','"+ds.escapeSQL(value)+"')
	 * @param str
	 * @return 
	 */
	escapeSQL(str: string): string;

	/**
	 * 执行一批sql。
	 * 
	 * @param multiSQLs 要执行的sql，可以包含多个statement语句。
	 * @param schema 
	 */
	executeSQLFile(multiSQLs: string | import("svr-api/fs").File, schema?: string): void;

	/**
	 * 把一个SQL分解为java JDBC可以执行的多条SQL。
	 *
	 * 一些语法规则：
	 *
	 * 1. 默认分隔符是分号，支持通过命令（如果语句中有一行是："delimiter //" 表示定义分割符为"//"）指定
	 *    新的分隔符，分割符如果出现在字段名（引号括起）、值（单引号括起）中、注释中，不能当作分割符。
	 * 2. 支持3种注释格式，--开头的、REM命令开头的，或多行注释斜杠+星号的注释。
	 * 3. 创建表、存储过程的语句会识别为一个完整的SQL语句。
	 *
	 * 拆分原则：
	 * 
	 * 1. 注释(单行、多行)不作处理，直接忽略
	 * 2. BEGIN-END、IF-END IF、()、{}、''、""、``、[]内部一律不进行拆分
	 * 3. 其他情况，根据分隔符进行拆分
	 * 4. 只有在空行之后行首不为SQL起始关键字时进行拆分
	 * 
	 * @param sql 可能含有多个SQL的字符串
	 */
	splitSQL(sql: string): string[];

	/**
	 * 解析SQL语句，返回相关信息。
	 * 
	 * 使用场景：
	 * 
	 * 1. 分析这个SQL的类型，是delete还是update等
	 * 2. 获取查询SQL的数据总行数的SQL（需要考虑对SQL进行一些优化，比如去掉orderby）
	 * 
	 * @param sql 一个独立的SQL
	 */
	parseSQL(sql: string): {
		/**
		 * SQL类型
		 */
		type: string

		/**
		 * 获取此次操作的数据库表的schema。可能为空。
		 */
		schema: string,

		/**
		 * 当前SQL操作的表名
		 */
		tableName: string

		/**
		 * 表示是否是DML语句，并操作了所有行，比如删除、更新或truncate了所有行。
		 */
		manipulateAllRows: true,

		/**
		 * 获取查询SQL的数据的总行数的SQL。
		 */
		countSQL: string
	}

	/**
	 * 依据一个表，或一个sql创建一个BulkDataSource对象，用于读写数据。
	 * 
	 * @param options 
	 */
	getBulkDataSource(options?: BulkDataOptions): BulkDataSource;
}

/** 导入导出数据文件格式 */
declare const enum FileType {
	CSV = 'csv',
	SZDB = 'szdb',
	CSZ = 'csz',
	DBF = 'dbf',
	XLS = 'xls',
	XLSX = 'xlsx'
}

/**
 * 提供一些跟数据库方言有关的api函数。
 * 
 * 对应后端的Dialect.java
 */
declare interface DbDialect {

	/**
	 * 获取默认schema的标识（即一个新创建的Connection的默认的Schema）。
	 *
	 * @return
	 */
	getDefaultSchema(): string;

	/**
	 * 将字符串中的特殊字符进行转义，避免sql中出现sql注入的情况。
	 *
	 * 几乎所有的数据库都支持字符串中的单引号用两个单引号转义，通常就是将字符串中的单引号替换为2个单
	 * 引号。
	 *
	 * @param str 待转义的字符串。
	 * @return 返回转义后的内容
	 */
	escapeSQL(str: string): string;

	/**
	 * 将一个标识符（表名、字段名等）转换成可以在SQL中使用的格式，对包含特殊字符或者是关键字的会进行
	 * quote处理，如果不需要转义则返回原值。
	 * 
	 * 不同的数据库有不同的quote规则，一般情况下都是'"'、mysql是'`'、sqlserver是']'。
	 *
	 * @param name 原始标识符。
	 * @return 如果有特殊符号或关键字，那么返回quote后的标识符，否则返回原值。
	 */
	formatSQLIdentifier(name: string): string;

	/**
	 * 根据数据库属性将一个数据库标识符（schema名或表名）转换成相应的大小写类型。
	 *
	 * 注意并不是转换成可以用于SQL中的标识符（那是{@link formatSQLIdentifier(String)}函数的功能），此函数是转换成
	 * 和数据库的元数据存储一致的格式，便于在数据库的元数据中查询对象。
	 *
	 * 1. oracle表名统一是大写的，查询一个表的元数据信息时，需要统一大写才能查询到
	 * 2. mysql统一小写的，linux上的mysql是敏感的
	 *
	 * @param id 标识符，schema名或表名等，如果是中括号括起来的，表示是转义过的，会根据不同的数据库
	 *           的规范进行处理。
	 * @return 按数据库的规则返回可以在其元数据表中进行查询定位的一个标识符。
	 */
	formatMetaIdentifier(id: string): string;

	/**
	 * 获取驱动中的指定的类。
	 *
	 * 有些数据库是基于mysql或pg的驱动开发的自己的驱动的，比如`com.huawei.gauss200.jdbc.Driver`，它
	 * 实际上是pg的`org.postgresql.Driver`，gauss的dbconnector实际上也是继承的PostgreSQL的连接器，如
	 * 果使用pg的dbconnector连接华为gauss，那么驱动可能配置的是 `com.huawei.gauss200.jdbc.Driver`，
	 * 如果连接器的扩展开发需要用到某些驱动jar包上的类就需要用到此函数。
	 *
	 * 以获取 CopyManager 对象为例，应该调用`getDriverClass("copy.CopyManager")`：
	 *
	 * 1. 当驱动为com.huawei.gauss200.jdbc.Driver时，返回：
	 *    com.huawei.gauss200.jdbc.copy.CopyManager
	 * 2. 当驱动为org.postgresql.Driver时，返回：`org.postgresql.copy.CopyManager`
	 *
	 * @param subClassPath 子类路径，路径相对于驱动所在的package。
	 * @return
	 * @throws ClassNotFoundException 
	 */
	getDriverClass(subClassPath: string): any;
}

/**
 * 一个负责创建和修改表结构的工具类。
 */
declare interface TableMetaDDLExecutor {

	/**
	 * 设置要创建或修改的表的信息。
	 * 
	 * @param tableInfo 
	 */
	setMetaData(tableInfo: TableMetaInfo): void;

	/**
	 * 设置原表信息，用于修改表结构时和{@link setMetaData}设置的表结构进行比较。
	 *
	 * @param tableInfo 
	 */
	setOriginalMetaData(tableInfo: TableMetaInfo): void;

	/**
	 * 目标表是否存在。
	 */
	isExists(): boolean;

	/**
	 * 如果表不存在则创建它，如果存在则什么都不做。
	 */
	createTableIfNotExists(): void;

	/**
	 * 创建一个物理表。
	 * 
	 * 当表已存在时会抛异常。
	 */
	createTable(): void;

	/**
	 * 修改一个物理表。
	 * 
	 * 当表不存在时会抛异常。
	 */
	alterTable(): void;

	/**
	 * 如果视图存在就重新创建它。
	 */
	createOrReplaceView(): void;

	/**
	 * 创建视图或物化视图
	 * 
	 * 当视图已存在时会抛异常。
	 */
	createView(): void;

	/**
	 * 返回执行的DDL
	 */
	getDDL(): string;

	/**
	 * 设置DDLExecutor的执行模式
	 * 
	 * 可能只想获取修改表的DDL。
	 * 
	 * @param mode 创建表或修改表
	 */
	setExecuteMode(mode: TableMetaDDLExecuteMode): string;

	/**
	 * 设置DDLExecutor执行时的参数信息
	 * 
	 * 如`ENABLE_ADJUST_LENGTH`，更多参数参见{@link TableMetaDDLExecuteParam}
	 * 
	 * @param key 参数名
	 * @param value 参数值
	 */
	setOption(key: string, value: any): void;
}

/**
 * 根据一个表的主键等信息，提供比较方便的查询和修改一个表的数据的工具对象。
 * TableData有三种使用的场景：
 * 1. 第一种场景是autoCommit为true。这种场景最常用，这种场景下直接调用本方法的增
 *    删改查方法即可访问数据库，不需要调用commit. rollback
 * 2. 第二种场景是autoCommit为false。如果操作数据库需要关心事务，多个增删改操作
 *    必须在一个事务中执行，那么需要先调用`setAutoCommit(false)`，禁用自动提交。
 *    然后在操作的最后调用commit()，在try-catch中调用rollback，下面是一个示例：
 * 3. 第三种场景是传入connection。如果在一个事务以外还要调用TableData以外的对象
 *    执行sql，为了实现一个事务，调用者要自己创建connection然后传给TableData。并
 *    且要自己commit. close连接
 *
 * 场景一的代码示例：
 * ```
 *  import db from "svr-api/db";
 *  var ds = db.getDefaultDatasource();
 *  var tableData = ds.openTableData("xxb");
 *  tableData.executeUpdate(sql);
 * ```
 *
 * 场景二的代码示例：
 * ```
 *  import db from "svr-api/db";
 *  var ds = db.getDefaultDatasource();
 *  var tableData = ds.openTableData("xxb");
 *  //还有种方式是设置ds.setAutoCommit(false);再创建tableData。这种方式不推荐使用，ds.setAutoCommit的这个方法就不推荐使用。
 *  //原因：这样设置会导致ds内部的更新方法不能提交。
 *  try{
 *      tableData.setAutoCommit(false);
 *      tableData.executeUpdate(sql);
 *      tableData.executeUpdate(sql2);
 *      tableData.commit();
 *  }catch(e){
 *      tableData.rollback();
 *      throw e;
 *  }
 * ```
 *
 * 场景三的代码示例：
 * ```
 *  //注意：使用外部传入conn的方式，就不能调用tableData内部的commit. rollback方法。需要使用者自己调用conn的commit. rollback. close。
 *  import db from "svr-api/db";
 *  var ds = db.getDefaultDatasource();
 *  var conn = ds.getConnection();
 *  try{
 *      conn.setAutoCommit(false);
 *      var tableData = ds.openTableData("xxb", null, conn);
 *      tableData.executeUpdate(sql);
 *      tableData.executeUpdate(sql2);
 *
 *      var tableData2 = ds.openTableData("xxb2", null, conn);
 *      tableData2.executeUpdate(sql3);
 *      tableData2.executeUpdate(sql4);
 *
 *      conn.commit();
 *  }catch(e){
 *      conn.rollback();
 *      throw e;
 *  }finally{
 *      conn && conn.close();
 *  }
 * ```
 */

declare interface TableData extends Closeable {
	/**
	 * 返回满足条件的数据行数。
	 *
	 * @param where 查询条件，可以是一个字符串，如`"FIELD1=123 AND FIELD2='abc'"`，也可以是一个
	 *     json，如`{"FIELD1": 123, "FIELD2": "abc"}`
	 * @returns 返回满足条件的数据行数。
	 */
	selectCount(where?: string | { [fieldName: string]: any }): number;

	/**
	 * 执行一个查询，并返回第一行数据的json
	 *
	 * @param columnNames 要查询的字段，如: `"*"`, `"FIELD1"`, `["FIELD1",
	 *     "FIELD2"]`
	 * @param where 查询条件，可以是一个字符串，如`"FIELD1=123 AND
	 *     FIELD2='abc'"`，也可以是一个json，如`{"FIELD1": 123, "FIELD2":
	 *     "abc"}`
	 * @param orderBy 排序字段 传一个字符串，字段和排序方式之间用空格分隔，字段
	 *     之间用逗号分隔，如:
	 *     1. `"FIELD1 DESC FIELD2 ASC"`
	 *     2. `"FIELD1  ASC, FIELD2"`
	 *     若未传递排序方式默认按升序排列
	 * @returns 当参数`columnNames`只是一个字符串字段时，返回的结果就是字段值，
	 *     如果是多个字段那么返回一个json对象，key是字段名，当数据不存在时返回
	 *     `null`
	 */
	selectFirst(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, orderBy?: string): { [fieldName: string]: any } | any;

	/**
	 * 执行一个查询并返回所有数据，一个json数组
	 *
	 * @param columnNames 要查询的字段，如: `"*"`, `"FIELD1"`, `["FIELD1",
	 *     "FIELD2"]`
	 * @param where 查询条件，可以是一个字符串，如`"FIELD1=123 AND
	 *     FIELD2='abc'"`，也可以是一个json，如`{"FIELD1": 123, "FIELD2": "abc"}`
	 * @param limit 行数限制，一个数字长度为1或2的数组，如：
	 *  1. `5`表示查询前5行
	 *  2. `[3, 5]`表示从第4行开始返回最多5行
	 *  3. 如果不传递，那么最多查询5万行，如果传递了，那么以传递的为准
	 * @param orderBy 排序字段 传一个字符串，字段和排序方式之间用空格分隔，字段
	 *     之间用逗号分隔，如:
	 *     1. `"FIELD1 DESC, FIELD2 ASC"`
	 *     2. `"FIELD1  ASC, FIELD2"`
	 *     若未传递排序方式默认按升序排列
	 * @returns 返回一个json数组，如果没有满足条件的额数据，返回空数组
	 */
	select(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, limit?: number | number[], orderBy?: string): Array<{ [fieldName: string]: any }>;

	/**
	 * 执行一个查询，并返回第一行数据的数组
	 *
	 * @param columnNames 要查询的字段，如: `"*"`, `"FIELD1"`, `["FIELD1",
	 *     "FIELD2"]`
	 * @param where 查询条件，可以是一个字符串，如`"FIELD1=123 AND
	 *     FIELD2='abc'"`，也可以是一个json，如`{"FIELD1": 123, "FIELD2":
	 *     "abc"}`
	 * @param orderBy 排序字段，传一个字符串，字段和排序方式之间用空格分隔，如
	 * @param orderBy 排序字段 传一个字符串，字段和排序方式之间用空格分隔，字段
	 *     之间用逗号分隔，如:
	 *     1. `"FIELD1 DESC FIELD2 ASC"`
	 *     2. `"FIELD1  ASC, FIELD2"`
	 *     若未传递排序方式默认按升序排列
	 * @returns 当参数`columnNames`只是一个字符串字段时，返回的结果就是字段值，
	 *     如果是多个字段那么返回一个数组，当数据不存在时返回`null`
	 */
	selectFirstRow(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, orderBy?: string): Array<any> | any;

	/**
	 * 执行一个查询并返回所有数据，一个二维数组
	 *
	 * @param columnNames 要查询的字段，如: `"*"`, `"FIELD1"`, `["FIELD1",
	 *     "FIELD2"]`
	 * @param where 查询条件，可以是一个字符串，如`"FIELD1=123 AND
	 *     FIELD2='abc'"`，也可以是一个json，如`{"FIELD1": 123, "FIELD2":
	 *     "abc"}`
	 * @param limit 行数限制，一个数字长度为1或2的数组，如：
	 *  1. `5`表示查询前5行
	 *  2. `[3, 5]`表示从第4行开始返回最多5行
	 *  3. 如果不传递，那么最多查询5万行，如果传递了，那么以传递的为准
	 * @param orderBy 排序字段 传一个字符串，字段和排序方式之间用空格分隔，字段
	 *     之间用逗号分隔，如:
	 *     1. `"FIELD1 DESC FIELD2 ASC"`
	 *     2. `"FIELD1  ASC, FIELD2"`
	 *     若未传递排序方式默认按升序排列
	 * @returns 返回一个二维数组，如果没有满足条件的额数据，返回空数组
	 */
	selectRows(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, limit?: number | number[], orderBy?: string): Array<Array<any>>;

	/**
	 * 插入数据，一行或多行
	 *
	 * 数据行可以是Map也可以是数组，大数据量的插入推荐用数组。
	 * @param data 要插入的数据，如: 
	 *  1. `{"FIELD1": 123, "FIELD2": "abc"}`表示插入一行
	 *  2. `[{"FIELD1": 123, "FIELD2": "abc"}, {"FIELD1": 456, "FIELD2":
	 *     "def"}]` 表示插入多行
	 *  3. `[[123, "abc"], [456,"def"]]` 表示插入多行
	 * @param fields 当data参数中一行的数据是用数组而不是Map表示时，需要指定
	 *     fields参数，用来指定字段顺序。
	 * @returns 返回插入的行数
	 * @throws SQLException 插入值主键重复抛出异常
	 */
	insert(data: { [fieldName: string]: any } | Array<{ [fieldName: string]: any }> | Array<Array<any>> | Array<any>, fields?: Array<string>): number;

	/**
	 * 删除数据，必须明确匹配条件，当条件为空时抛出异常
	 *
	 * @param where 匹配条件，可以是一个字符串，如"FIELD1=123 AND
	 *     FIELD2='abc'"，也可以是一个json，如`{"FIELD1": 123, "FIELD2": "abc"}`
	 * @returns 返回删除的行数
	 */
	del(where: string | { [fieldName: string]: any }): number;

	/**
	 * 删除所有数据行
	 *
	 * @returns 返回删除的行数
	 */
	deleteAll(): number;

	/**
	 * 清空表数据，不可回滚
	 */
	truncate(): void;

	/**
	 * 更新数据
	 *
	 * @param columnValues 要更新的字段及值，如`{"FIELD1": "FIELD1+123",
	 *     "FIELD2": "substr(FIELD3,0,3)"}`
	 * @param where 匹配条件，可以是一个字符串，如"FIELD1=123 AND
	 *     FIELD2='abc'"，也可以是一个json，如`{"FIELD1": 123, "FIELD2": "abc"}`
	 * @returns 返回删除的行数
	 */
	update(columnValues: { [fieldName: string]: any }, where?: string | { [fieldName: string]: any }): number;

	/**
	 * 将数据库表导出为csv|excel|dbf|szdb文件，如：`exportData({file: "/succez/exp"})`
	 */
	exportData(args: {
		/**导出到哪个文件，可以传递目标文件路径或文件对象 */
		file: any,
		/**文件格式，为空时自动从文件名中分析 */
		fileType?: FileType,
		/**csv文件的分隔符，默认逗号 */
		separator?: string,
		/**csv文件的编码，默认utf-8 */
		encoding?: string,
		/**日期的导出格式，默认 yyyy-MM-dd */
		dateFormat?: string,
		/**时间戳的导出格式，默认 yyyy-MM-dd HH:mm:ss */
		timestampFormat?: string,
		/**
		 * 第一行是否是字段名，默认为false
		 *
		 * 说明：
		 * 1. 若为true，会生成非`#`开头的列头，如：`["id", "name", "sex"]`
		 * 2. 若为false，会生成`#`开头的列头，如：`["#id(I|20)", "name(C|20)",
		 *    "sex(C|20)"]`
		 */
		firstRowIsFieldNames?: boolean,
		/**
		 * 是否只导出字段名(即不包含结构信息)，默认为false
		 *
		 * 说明：
		 * 1. 若为true，不会导出表结构信息，如：`[["id", "name", "sex"], ["1",
		 *    "zhangsan", "male"], ["2", "lisi", "male"], ["3", "liming",
		 *    "male"]]` 
		 * 2. 若为false，会导出表结构信息，如：`[["id(I|20)", "name(C|20)",
		 *    "sex(C|20)"], ["1", "zhangsan", "male"], ["2", "lisi", "male"],
		 *    ["3", "liming", "male"]]`
		 */
		titleOnlyField?: boolean
	}): void;

	/**
	 * 将csv|excel|dbf|szdb数据文件导入数据库表中
	 *
	 * @returns 返回导入后的返回信息，比如导入多少行. 耗时多少等
	 */
	importData(args: {
		/**
		 * 要导入的文件，可为文件对象、路径名或输入流
		 *
		 * 暂不支持输入流导入DBF文件
		 */
		file: any,
		/** 导入模式，默认clear，表示清空目标表后导入新的数据 */
		importMode?: DataImportMode;
		/**文件分隔符，默认逗号 */
		separator?: string,
		/**文件编码，默认utf-8 */
		encoding?: string,
		/**日期的导出格式，默认 yyyy-MM-dd  */
		dateFormat?: string,
		/**时间戳的导出格式，默认 yyyy-MM-dd HH:mm:ss */
		timestampFormat?: string,
		/**
		 * 第一行是否是字段名，默认为false
		 *
		 * 说明：
		 * 1. 若为true，会生成非`#`开头的列头，如：`["id", "name", "sex"]`
		 * 2. 若为false，会生成`#`开头的列头，如：`["#id(I|20)", "name(C|20)",
		 *    "sex(C|20)"]`
		 */
		firstRowIsFieldNames?: boolean,
	}): {
		/** 返回导入的表名 */
		importTable: string;
		/** 返回导入总行数 */
		importRowCount: number;
		/** 返回忽略行 */
		rejectsRows: Array<number>;
		/** 导入耗时，单位毫秒 */
		totalTime: number;
		/** 返回执行的sql */
		sql: string;
	};

	/**
	 * 设置执行的更新语句是否自动提交，默认true。
	 *
	 * 1. 如果是外部传入的conn，那么此类不控制事务，autoCommit对传入conn不起作
	 *    用，commit/rollback/close方法什么都不做。
	 * 2. 自己获取的conn，当autoCommit=true，没有事务，每次执行sql的调用，用完就
	 *    close，commit/rollback/close也什么都不做。
	 * 3. 自己获取的conn，当autoCommit=false，内部开启事务。可以多次执行sql，每
	 *    次执行完不close连接。 commit和出异常rollback的时候自动close连接。增加
	 *    close方法，如果con没有close，则关闭。当autoCommit=false，推荐使用
	 *    try...catch..finally...在finally块调用close方法，防止连接漏洞。
	 * @param autoCommit 
	 */
	setAutoCommit(autoCommit: boolean): void;

	/**
	 * 提交所做的修改。只有当`Datasource`的`autoCommit`是`false`（默认是
	 * `false`）时,并且连接对象是内部生成的，才需要主动调用此函数提交数据。
	 *
	 * @warn 该方法仅用于内部conn且autoCommit=false的时候调用，请勿在外部传入
	 * conn是调用，外部传入conn时需要使用者自己管理。
	 */
	commit(): void;

	/**
	 * 回滚所做的修改。
	 *
	 * @warn 同commit()方法一样，请不要在外部传入conn时调用。
	 */
	rollback(): void;
}

/**
 * 数据库的元数据信息
 */
declare interface DatasourceMetaData {

	/**
	 * 完整的数据库名
	 */
	getDatabaseProductName(): string;

	/**
	 * 主版本号
	 */
	getDatabaseMajorVersion(): number;

	/**
	 * 副版本号
	 */
	getDatabaseMinorVersion(): number;

	/**
	 * 数据库完整的版本号
	 */
	getDatabaseProductVersion(): string;

	/**
	 * 获取jdbc驱动的版本号
	 */
	getDriverVersion(): string;

	/**
	 * 获取jdbc驱动的主版本号
	 */
	getDriverMajorVersion(): number;

	/**
	 * 返回schema列表
	 * @returns 没有任何结果时返回空数组（不是null）
	 */
	getSchemas(catalog?: string): string[];

	/**
	 * 获取表列表。
	 *
	 * 这个表列表是广义上的，包括所有对象：物理表、视图、同义词、物化视图等。
	 *
	 * @param readComments 是否同时查询表的描述信息，有些数据库查询表描述性能比较低，默认false。
	 * @param schema 传递null表示使用当前默认的schema，大小写是否敏感依赖具体数据库的实现，支持传递
	 *      中括号转义后的内容。
	 * @return 不存在时返回空数组
	 */
	getTables(readComments?: boolean, schema?: string): Array<TableMetaData>;

}


/**
 * DDLExecutor执行方式
 */
declare const enum TableMetaDDLExecuteMode {
	/**
	 * 创建表
	 */
	CREATE = "CREATE",
	/**
	 * 修改表
	 */
	ALTER = "ALTER"
}

/**
 * DDLExecutor执行相关参数
 */
declare const enum TableMetaDDLExecuteParam {

	/**
	 * 当此参数为`true`时，直接将原表结构同步为目标表结构，为全量同步。
	 * 
	 * 修改表结构时生效。
	 *
	 * 默认为`false`
	 */
	ENABLE_ALTER_SYNC = "ENABLE_ALTER_SYNC",

	/**
	 * 当无法修改目标表结构的时候可以选择创建新表并复制数据。
	 *
	 * 当{@link TableMetaDDLExecutor#setExecuteMode()}设置为
	 * {@link TableMetaDDLExecuteMode#ALTER}时，如果表已存在，且有
	 * 大量数据，调整表结构可能会非常慢，修改表结构可能不可行，此时也许创建新表
	 * 并复制数据更好。
	 *
	 * 当执行copy表时，会自动在复制完数据后将原表rename成一个备份表（备份表的表
	 * 名都是`BAK_原表名_序
	 * 号`），并将新表rename成原表的名字。
	 *
	 * 默认`false`，总是不使用复制数据的方式。
	 */
	ENABLE_ALTER_ORCOPY = "ENABLE_ALTER_ORCOPY",

	/**
	 * 创建表或视图时有效，当表不存在时执行创建，存在时什么都不做。
	 * 
	 * 默认`false`。
	 */
	ENABLE_CREATE_IFNOTEXISTS = "ENABLE_CREATE_IFNOTEXISTS",

	/**
	 * 不存在就创建或存在就确保结构一致。
	 * 
	 * 创建表时有效，如果不存在就重新创建它，如果存在，就确保已存在的表的结构和要创建的一致，不一致
	 * 就修改它。
	 *
	 * 默认`false`。
	 */
	ENABLE_CREATE_ORALTER = "ENABLE_CREATE_ORALTER",

	/**
	 * 创建视图时有效，如果视图存在就重新创建它，执行`create or replace`语句。
	 * 
	 * 默认`false`。
	 */
	ENABLE_CREATE_ORREPLACE = "ENABLE_CREATE_ORREPLACE",

	/**
	 * 当表名冲突或未指定表名时，是否允许自动更改表名。
	 * 
	 * 默认`false`
	 */
	ENABLE_CHANGE_TABLENAME = "ENABLE_CHANGE_TABLENAME",

	/**
	 * 是否允许修改或设置表备注。
	 *
	 * 此选项在创建或修改模式下都有效，通常用于控制修改范，有些场景下不需要备注，或则修改备注很慢可
	 * 以设置为`false`，此时不会改或设置表备注。
	 *
	 * 默认为`true`
	 */
	ENABLE_TABLE_COMMENT = "ENABLE_TABLE_COMMENT",

	/**
	 * 是否允许修改或设置字段备注。
	 *
	 * 此选项在创建或修改模式下都有效，通常用于控制修改范，有些场景下不需要备注，或则修改备注很慢可
	 * 以设置为`false`，此时不会改或设置字段备注。
	 *
	 * 默认为`true`
	 */
	ENABLE_COLUMN_COMMENT = "ENABLE_COLUMN_COMMENT",

	/**
	 * 是否DROP不需要的表。
	 *
	 * 当{@link TableMetaDDLExecutor#setExecuteMode()}设置为
	 * {@link TableMetaDDLExecuteMode.ALTER}时，如果同时启用了
	 * {@link ENABLE_ALTER_ORCOPY}或{@link ENABLE_CHANGE_TABLENAME}，那么可能会
	 * 创建新表替代旧表，此选项决定旧表是否最后被drop掉。
	 *
	 * 为了数据安全，此选项默认false，不用的表默认留着用户自己处理，旧表会被
	 * rename未一个备份表的名字，备份表的表名都是`BAK_原表名_序号`。
	 *
	 * 默认为`false`
	 */
	ENABLE_DROP_UNUSED_TABLE = "ENABLE_DROP_UNUSED_TABLE",

	/**
	 * 是否进行严格的字段长度修改。
	 *
	 * 当{@link #setExecuteMode()}设置为{@link #EXECUTE_MODE_ALTER}或{@link #EXECUTE_MODE_SYNC}时，
	 * 且允许修改字段时有效。
	 *
	 * 设置为true将执行严格的字段长度修改，将结构修改为和传入的新结构字段长度完全一致，此选项默认为
	 * false，执行宽松的修改模式，仅仅确保数据的兼容性即可，有如下规则：
	 *
	 * 1. 整形长度，当长度从大改小时，尽量不调整字段类型，从小改大时只要当前类型允许这个长度也尽量不
	 *    修改。比如：整形长度12改为4，严格修改就是bigint改为smallint，宽松模式下将不修改。
	 * 2. 浮点型，类似整形，只要能兼容，尽量不调整。
	 * 2. 字符类型，当长度从大改小时，也尽量不调整。
	 *
	 * 默认为`false`
	 */
	ENABLE_STRICT_ALTER_COLUMN = "ENABLE_STRICT_ALTER_COLUMN",

	/**
	 * 是否允许自动调整字段的长度。
	 *
	 * 传递`true`时，根据数据库的限制，自动调整字段长度，比如：主键列组合长度超过限制等。
	 *
	 * 默认为`true`。
	 */
	ENABLE_ADJUST_LENGTH = "AUTO_ADJUST_FIELD_LENGTH",

	/**
	 * 是否允许自动调整字段的精度。
	 *
	 * 传递`true`时，当浮点型字段精度超过数据库限制时，调整为数据库最大精度。
	 *
	 * 默认为`true`。
	 */
	ENABLE_ADJUST_SCALE = "AUTO_ADJUST_FIELD_SCALE"

}

/**
 * 索引排序方式
 */
declare const enum SQLSortMode {
	/**
	 * 升序
	 */
	ASC = "asc",

	/**
	 * 降序
	 */
	DESC = "desc"
}

/**
 * 数据库null排序规则。
 *
 * 和{@link SQLSortMode}配合使用。
 */
declare const enum SQLNullsSortType {
	/**
	 * 数据库默认
	 */
	DEFAULT = "dbdefault",

	/**
	 * null在最前
	 */
	FIRST = "first",

	/**
	 * null在最后
	 */
	LAST = "last"
}

/**
 * jdbc数据库连接对象，用于执行更底层的api操作
* A JDBC Connection. For documentation of this class, see
* java.sql.Connection.
*/
declare interface Connection {
	//clearWarnings(): void;
	close(): void;
	commit(): void;
	// createArrayOf(typeName: string, elements: Object[]): JdbcArray;
	// createBlob(): JdbcBlob;
	// createClob(): JdbcClob;
	// createNClob(): JdbcClob;
	// createSQLXML(): JdbcSQLXML;
	// createStatement(): JdbcStatement;
	// createStatement(resultSetType: number, resultSetConcurrency: number): JdbcStatement;
	// createStatement(resultSetType: number, resultSetConcurrency: number, resultSetHoldability: number): JdbcStatement;
	// createStruct(typeName: string, attributes: Object[]): JdbcStruct;
	// getAutoCommit(): boolean;
	// getCatalog(): string;
	// getHoldability(): number;
	// getMetaData(): JdbcDatabaseMetaData;
	// getTransactionIsolation(): number;
	// getWarnings(): string[];
	// isClosed(): boolean;
	// isReadOnly(): boolean;
	// isValid(timeout: number): boolean;
	// nativeSQL(sql: string): string;
	// prepareCall(sql: string): JdbcCallableStatement;
	// prepareCall(sql: string, resultSetType: number, resultSetConcurrency: number): JdbcCallableStatement;
	// prepareCall(sql: string, resultSetType: number, resultSetConcurrency: number, resultSetHoldability: number): JdbcCallableStatement;
	prepareStatement(sql: string): JdbcPreparedStatement;
	// prepareStatement(sql: string, autoGeneratedKeys: number): JdbcPreparedStatement;
	// prepareStatement(sql: string, resultSetType: number, resultSetConcurrency: number): JdbcPreparedStatement;
	// prepareStatement(sql: string, resultSetType: number, resultSetConcurrency: number, resultSetHoldability: number): JdbcPreparedStatement;
	// prepareStatementByIndex(sql: string, indices: number[]): JdbcPreparedStatement;
	// prepareStatementByName(sql: string, columnNames: string[]): JdbcPreparedStatement;
	// releaseSavepoint(savepoint: JdbcSavepoint): void;
	rollback(): void;
	// rollback(savepoint: JdbcSavepoint): void;
	setAutoCommit(autoCommit: boolean): void;
	//setCatalog(catalog: string): void;
	// setHoldability(holdability: number): void;
	// setReadOnly(readOnly: boolean): void;
	// setSavepoint(): JdbcSavepoint;
	// setSavepoint(name: string): JdbcSavepoint;
	// setTransactionIsolation(level: number): void;
}

/**
 * A JDBC PreparedStatement. For documentation of this class, see
 * java.sql.PreparedStatement.
 */
declare interface JdbcPreparedStatement {
	addBatch(): void;
	addBatch(sql: string): void;
	cancel(): void;
	clearBatch(): void;
	clearParameters(): void;
	clearWarnings(): void;
	close(): void;
	execute(): boolean;
	// execute(sql: string): boolean;
	// execute(sql: string, autoGeneratedKeys: number, sql_: string, columnIndexes: number[]): boolean;
	// execute(sql: string, autoGeneratedKeys: number, sql_: string, columnIndexes: number[]): boolean;
	// execute(sql: string, columnNames: string[]): boolean;
	executeBatch(): number[];
	executeQuery(): JdbcResultSet;
	// executeQuery(sql: string): JdbcResultSet;
	executeUpdate(): number;
	// executeUpdate(sql: string): number;
	// executeUpdate(sql: string, autoGeneratedKeys: number, sql_: string, columnIndexes: number[]): number;
	// executeUpdate(sql: string, autoGeneratedKeys: number, sql_: string, columnIndexes: number[]): number;
	// executeUpdate(sql: string, columnNames: string[]): number;
	// getConnection(): JdbcConnection;
	// getFetchDirection(): number;
	// getFetchSize(): number;
	// getGeneratedKeys(): JdbcResultSet;
	// getMaxFieldSize(): number;
	// getMaxRows(): number;
	getMetaData(): JdbcResultSetMetaData;
	// getMoreResults(): boolean;
	// getMoreResults(current: number): boolean;
	// getParameterMetaData(): JdbcParameterMetaData;
	// getQueryTimeout(): number;
	getResultSet(): JdbcResultSet;
	// getResultSetConcurrency(): number;
	// getResultSetHoldability(): number;
	// getResultSetType(): number;
	getUpdateCount(): number;
	// getWarnings(): string[];
	// isClosed(): boolean;
	// isPoolable(): boolean;
	setArray(parameterIndex: number, x: JdbcArray): void;
	setBigDecimal(parameterIndex: number, x: number): void;
	setBlob(parameterIndex: number, x: JdbcBlob): void;
	setBoolean(parameterIndex: number, x: boolean): void;
	setByte(parameterIndex: number, x: number): void;
	setBytes(parameterIndex: number, x: number[]): void;
	setClob(parameterIndex: number, x: JdbcClob): void;
	setCursorName(name: string): void;
	setDate(parameterIndex: number, x: JdbcDate): void;
	setDate(parameterIndex: number, x: JdbcDate, timeZone: string): void;
	setDouble(parameterIndex: number, x: number): void;
	setEscapeProcessing(enable: boolean): void;
	setFetchDirection(direction: number): void;
	setFetchSize(rows: number): void;
	setFloat(parameterIndex: number, x: number): void;
	setInt(parameterIndex: number, x: number): void;
	setLong(parameterIndex: number, x: number): void;
	setMaxFieldSize(max: number): void;
	setMaxRows(max: number): void;
	setNClob(parameterIndex: number, x: JdbcClob): void;
	setNString(parameterIndex: number, x: string): void;
	setNull(parameterIndex: number, sqlType: number): void;
	setNull(parameterIndex: number, sqlType: number, typeName: string): void;
	setObject(index: number, x: any): void;
	setObject(parameterIndex: number, x: any, targetSqlType: number): void;
	setObject(parameterIndex: number, x: any, targetSqlType: number, scaleOrLength: number): void;
	setPoolable(poolable: boolean): void;
	setQueryTimeout(seconds: number): void;
	setRef(parameterIndex: number, x: JdbcRef): void;
	// setRowId(parameterIndex: number, x: JdbcRowId): void;
	// setSQLXML(parameterIndex: number, x: JdbcSQLXML): void;
	setShort(parameterIndex: number, x: number): void;
	setString(parameterIndex: number, x: string): void;
	setTime(parameterIndex: number, x: JdbcTime): void;
	setTime(parameterIndex: number, x: JdbcTime, timeZone: string): void;
	setTimestamp(parameterIndex: number, x: JdbcTimestamp): void;
	setTimestamp(parameterIndex: number, x: JdbcTimestamp, timeZone: string): void;
	setURL(parameterIndex: number, x: string): void;
}

/**
 * A JDBC ResultSet. For documentation of this class, see java.sql.ResultSet
 * .
 */
declare interface JdbcResultSet {
	absolute(row: number): boolean;
	afterLast(): void;
	beforeFirst(): void;
	cancelRowUpdates(): void;
	clearWarnings(): void;
	close(): void;
	// deleteRow(): void;
	findColumn(columnLabel: string): number;
	first(): boolean;
	getArray(columnIndex: number): JdbcArray;
	getArray(columnLabel: string): JdbcArray;
	getBigDecimal(columnIndex: number): number;
	getBigDecimal(columnLabel: string): number;
	getBlob(columnIndex: number): JdbcBlob;
	getBlob(columnLabel: string): JdbcBlob;
	getBoolean(columnIndex: number): boolean;
	getBoolean(columnLabel: string): boolean;
	getByte(columnIndex: number): number;
	getByte(columnLabel: string): number;
	getBytes(columnIndex: number): number[];
	getBytes(columnLabel: string): number[];
	getClob(columnIndex: number): JdbcClob;
	getClob(columnLabel: string): JdbcClob;
	getConcurrency(): number;
	getCursorName(): string;
	getDate(columnIndex: number): JdbcDate;
	getDate(columnIndex: number, timeZone: string): JdbcDate;
	getDate(columnLabel: string): JdbcDate;
	getDate(columnLabel: string, timeZone: string): JdbcDate;
	getDouble(columnIndex: number): number;
	getDouble(columnLabel: string): number;
	getFetchDirection(): number;
	getFetchSize(): number;
	getFloat(columnIndex: number): number;
	getFloat(columnLabel: string): number;
	getHoldability(): number;
	getInt(columnIndex: number): number;
	getInt(columnLabel: string): number;
	getLong(columnIndex: number): number;
	getLong(columnLabel: string): number;
	getMetaData(): JdbcResultSetMetaData;
	getNClob(columnIndex: number): JdbcClob;
	getNClob(columnLabel: string): JdbcClob;
	getNString(columnIndex: number): string;
	getNString(columnLabel: string): string;
	getObject(columnIndex: number): any;
	getObject(columnLabel: string): any;
	getRef(columnIndex: number): JdbcRef;
	getRef(columnLabel: string): JdbcRef;
	getRow(): number;
	// getRowId(columnIndex: number): JdbcRowId;
	// getRowId(columnLabel: string): JdbcRowId;
	// getSQLXML(columnIndex: number): JdbcSQLXML;
	// getSQLXML(columnLabel: string): JdbcSQLXML;
	getShort(columnIndex: number): number;
	getShort(columnLabel: string): number;
	// getStatement(): JdbcStatement;
	getString(columnIndex: number): string;
	getString(columnLabel: string): string;
	getTime(columnIndex: number): JdbcTime;
	getTime(columnIndex: number, timeZone: string): JdbcTime;
	getTime(columnLabel: string): JdbcTime;
	getTime(columnLabel: string, timeZone: string): JdbcTime;
	getTimestamp(columnIndex: number): JdbcTimestamp;
	getTimestamp(columnIndex: number, timeZone: string): JdbcTimestamp;
	getTimestamp(columnLabel: string): JdbcTimestamp;
	getTimestamp(columnLabel: string, timeZone: string): JdbcTimestamp;
	getType(): number;
	getURL(columnIndex: number): string;
	getURL(columnLabel: string): string;
	getWarnings(): string[];
	insertRow(): void;
	isAfterLast(): boolean;
	isBeforeFirst(): boolean;
	isClosed(): boolean;
	isFirst(): boolean;
	isLast(): boolean;
	last(): boolean;
	moveToCurrentRow(): void;
	moveToInsertRow(): void;
	next(): boolean;
	previous(): boolean;
	refreshRow(): void;
	relative(rows: number): boolean;
	rowDeleted(): boolean;
	rowInserted(): boolean;
	rowUpdated(): boolean;
	setFetchDirection(direction: number): void;
	setFetchSize(rows: number): void;
	// updateArray(columnIndex: number, x: JdbcArray): void;
	// updateArray(columnLabel: string, x: JdbcArray): void;
	// updateBigDecimal(columnIndex: number, x: number): void;
	// updateBigDecimal(columnLabel: string, x: number): void;
	// updateBlob(columnIndex: number, x: JdbcBlob): void;
	// updateBlob(columnLabel: string, x: JdbcBlob): void;
	// updateBoolean(columnIndex: number, x: boolean): void;
	// updateBoolean(columnLabel: string, x: boolean): void;
	// updateByte(columnIndex: number, x: number): void;
	// updateByte(columnLabel: string, x: number): void;
	// updateBytes(columnIndex: number, x: number[]): void;
	// updateBytes(columnLabel: string, x: number[]): void;
	// updateClob(columnIndex: number, x: JdbcClob): void;
	// updateClob(columnLabel: string, x: JdbcClob): void;
	// updateDate(columnIndex: number, x: JdbcDate): void;
	// updateDate(columnLabel: string, x: JdbcDate): void;
	// updateDouble(columnIndex: number, x: Number): void;
	// updateDouble(columnLabel: string, x: Number): void;
	// updateFloat(columnIndex: number, x: Number): void;
	// updateFloat(columnLabel: string, x: Number): void;
	// updateInt(columnIndex: number, x: number): void;
	// updateInt(columnLabel: string, x: number): void;
	// updateLong(columnIndex: number, x: number): void;
	// updateLong(columnLabel: string, x: number): void;
	// updateNClob(columnIndex: number, x: JdbcClob): void;
	// updateNClob(columnLabel: string, x: JdbcClob): void;
	// updateNString(columnIndex: number, x: string): void;
	// updateNString(columnLabel: string, x: string): void;
	// updateNull(columnIndex: number): void;
	// updateNull(columnLabel: string): void;
	// updateObject(columnIndex: number, x: Object): void;
	// updateObject(columnIndex: number, x: Object, scaleOrLength: number): void;
	// updateObject(columnLabel: string, x: Object): void;
	// updateObject(columnLabel: string, x: Object, scaleOrLength: number): void;
	// updateRef(columnIndex: number, x: JdbcRef): void;
	// updateRef(columnLabel: string, x: JdbcRef): void;
	// updateRow(): void;
	// updateRowId(columnIndex: number, x: JdbcRowId): void;
	// updateRowId(columnLabel: string, x: JdbcRowId): void;
	// updateSQLXML(columnIndex: number, x: JdbcSQLXML): void;
	// updateSQLXML(columnLabel: string, x: JdbcSQLXML): void;
	// updateShort(columnIndex: number, x: number): void;
	// updateShort(columnLabel: string, x: number): void;
	// updateString(columnIndex: number, x: string): void;
	// updateString(columnLabel: string, x: string): void;
	// updateTime(columnIndex: number, x: JdbcTime): void;
	// updateTime(columnLabel: string, x: JdbcTime): void;
	// updateTimestamp(columnIndex: number, x: JdbcTimestamp): void;
	// updateTimestamp(columnLabel: string, x: JdbcTimestamp): void;
	wasNull(): boolean;
}

/**
* A JDBC ResultSetMetaData. For documentation of this class, see
* java.sql.ResultSetMetaData.
*/
declare interface JdbcResultSetMetaData {
	getCatalogName(column: number): string;
	getColumnClassName(column: number): string;
	getColumnCount(): number;
	getColumnDisplaySize(column: number): number;
	getColumnLabel(column: number): string;
	getColumnName(column: number): string;
	getColumnType(column: number): number;
	getColumnTypeName(column: number): string;
	getPrecision(column: number): number;
	getScale(column: number): number;
	getSchemaName(column: number): string;
	getTableName(column: number): string;
	isAutoIncrement(column: number): boolean;
	isCaseSensitive(column: number): boolean;
	isCurrency(column: number): boolean;
	isDefinitelyWritable(column: number): boolean;
	isNullable(column: number): number;
	isReadOnly(column: number): boolean;
	isSearchable(column: number): boolean;
	isSigned(column: number): boolean;
	isWritable(column: number): boolean;
}

/**
* A JDBC Array. For documentation of this class, see java.sql.Array
* .
*/
declare interface JdbcArray {
	free(): void;
	getArray(): any;
	getArray(index: number, count: number): any;
	getBaseType(): number;
	getBaseTypeName(): string;
	getResultSet(): JdbcResultSet;
	getResultSet(index: number, count: number): JdbcResultSet;
}

/**
 * A JDBC Blob. For documentation of this class, see java.sql.Blob
 * .
 */
declare interface JdbcBlob {
	free(): void;
	getAppsScriptBlob(): Blob;
	getAs(contentType: string): Blob;
	getBytes(position: number, length: number): number[];
	length(): number;
	position(pattern: number[], start: number): number;
	position(pattern: JdbcBlob, start: number): number;
	// setBytes(position: number, blobSource: Base.BlobSource): number;
	// setBytes(position: number, blobSource: Base.BlobSource, offset: number, length: number): number;
	setBytes(position: number, bytes: number[]): number;
	setBytes(position: number, bytes: number[], offset: number, length: number): number;
	truncate(length: number): void;
}
/**
 * A data interchange object for Apps Script services.
 */
declare interface Blob {
	copyBlob(): Blob;
	getAs(contentType: string): Blob;
	getBytes(): number[];
	getContentType(): string;
	getDataAsString(): string;
	getDataAsString(charset: string): string;
	getName(): string;
	isGoogleType(): boolean;
	setBytes(data: number[]): Blob;
	setContentType(contentType: string): Blob;
	setContentTypeFromExtension(): Blob;
	setDataFromString(string: string): Blob;
	setDataFromString(string: string, charset: string): Blob;
	setName(name: string): Blob;
	getAllBlobs(): Blob[];
}

/**
 * A JDBC Clob. For documentation of this class, see java.sql.Clob
 * .
 */
declare interface JdbcClob {
	free(): void;
	getAppsScriptBlob(): Blob;
	getAs(contentType: string): Blob;
	getSubString(position: number, length: number): string;
	length(): number;
	position(search: JdbcClob, start: number): number;
	position(search: string, start: number): number;
	// setString(position: number, blobSource: Base.BlobSource): number;
	// setString(position: number, blobSource: Base.BlobSource, offset: number, len: number): number;
	setString(position: number, value: string): number;
	setString(position: number, value: string, offset: number, len: number): number;
	truncate(length: number): void;
}

/**
 * A JDBC Date. For documentation of this class, see java.sql.Date
 * .
 */
declare interface JdbcDate {
	after(when: JdbcDate): boolean;
	before(when: JdbcDate): boolean;
	getDate(): number;
	getMonth(): number;
	getTime(): number;
	getYear(): number;
	setDate(date: number): void;
	setMonth(month: number): void;
	setTime(milliseconds: number): void;
	setYear(year: number): void;
}

/**
 * A JDBC Ref. For documentation of this class, see java.sql.Ref.
 */
declare interface JdbcRef {
	getBaseTypeName(): string;
	getObject(): any;
	setObject(object: any): void;
}


/**
   * A JDBC Time. For documentation of this class, see java.sql.Time
   * .
   */
declare interface JdbcTime {
	after(when: JdbcTime): boolean;
	before(when: JdbcTime): boolean;
	getHours(): number;
	getMinutes(): number;
	getSeconds(): number;
	getTime(): number;
	setHours(hours: number): void;
	setMinutes(minutes: number): void;
	setSeconds(seconds: number): void;
	setTime(milliseconds: number): void;
}

/**
 * A JDBC Timestamp. For documentation of this class, see java.sql.Timestamp
 * .
 */
declare interface JdbcTimestamp {
	after(when: JdbcTimestamp): boolean;
	before(when: JdbcTimestamp): boolean;
	getDate(): number;
	getHours(): number;
	getMinutes(): number;
	getMonth(): number;
	getNanos(): number;
	getSeconds(): number;
	getTime(): number;
	getYear(): number;
	setDate(date: number): void;
	setHours(hours: number): void;
	setMinutes(minutes: number): void;
	setMonth(month: number): void;
	setNanos(nanoseconds: number): void;
	setSeconds(seconds: number): void;
	setTime(milliseconds: number): void;
	setYear(year: number): void;
}

/**
 * 一个唯一序号生成器。
 *
 * 生成的序号是递增的，但不确保连续，产生过的序号就不再会重复产生，确保集群上唯一。
 */
declare interface NumberSequencer {
	/**
	 * 产生一个新的序号。
	 *
	 * @return 返回一个新的序号
	 */
	next(): number;

	/**
	 * 批量产生一批序列号，性能比多次调用next()更好。
	 *
	 * @param count 产生的数量。
	 * @return 返回一批新的序号
	 */
	batchNext(count: number): number[];
}

/**
 * Redis对象
 */
declare interface Redis {

	/**
	 * 返回Jedis
	 */
	getJedis(): any;

	/**
	 * 往redis数据库中写入一条数据
	 * @param key
	 * @param value
	 */
	set(key: string, value: string): string;

	/**
	 * 从redis中读取一条数据
	 * @param key 
	 */
	get(key: string): string;

	/**
	 * 为hash表中的字段赋值，将哈希表 key 中的域 field 的值设为 value
	 * @param key 
	 * @param field 
	 * @param value 
	 */
	hset(key: string, field: string, value: string): number;

	/**
	 * 返回哈希表key中给定域field的值
	 * @param key 
	 */
	hget(key: string, field: string): string;

	/**
	 * 同时将多个 field-value (域-值)对设置到哈希表 key 中
	 * @param key 
	 * @param hash 
	 */
	hmset(key: string, hash: { [fieldName: string]: any }): string;

	/**
	 * 返回哈希表 key 中，一个或多个给定域的值
	 * @param key 
	 * @param field 
	 */
	hmget(key: string, ...params: any): Array<string>;

	/**
	 * 判断key对应字段的是否存在
	 * @param key 
	 */
	exists(key: string): boolean;

	/**
	 * 删除键为key的数据项
	 * @param key 要删除的key
	 * @returns 返回受影响的行数
	 */
	del(key: string): number;

	/**
	 * 设置key的过期时间
	 * @param key 
	 * @param time 
	 * @returns 设置成功返回1，key不存在或者不能设置时，返回0
	 */
	expire(key: string, time: number): number;

	/**
	 * 移除键为key的生存时间限制
	 * @param key 
	 * @returns 移除成功的时候返回1，移除失败(未设置生存时间)返回0
	 */
	persist(key: string): number;

	/**
	 * 返回key对应value的数据类型
	 * @param key 
	 */
	type(key: string): string;

	/**
	 * 在key对应的value后面扩展字符appendStr
	 * @param key 
	 * @param appendStr 
	 * @returns 追加字符串后的总长度
	 */
	append(key: string, appendStr: string): number;

	/**
	 * 将key对应的value自加1
	 * @param key 
	 * @returns 返回自增之后的value
	 */
	incr(key: string): number;

	/**
	 * 将key对应的value自加length
	 * @param key 
	 * @param length 
	 * @returns 返回自增之后的value
	 */
	incrBy(key: string, length: number): number;

	/**
	 * 让key对应的Map中的field字段的值自增length长度
	 * @param key 
	 * @param field 
	 * @param length 
	 */
	hincrBy(key: string, field: string, length: number): any;

	/**
	 * 将key对应的value自加1
	 * @param key 
	 * @returns 返回自增之后的value
	 */
	decr(key: string): number;

	/**
	 * 将key对应的value自加length
	 * @param key 
	 * @param length 
	 * @returns 返回自增之后的value
	 */
	decrBy(key: string, length: number): number;

	/**
	 * 表示往key对应的list左插入一个元素
	 * @param key 
	 * @param params 
	 * @returns 
	 */
	lpush(key: string, Vn: string): number;

	/**
	 * 往key对应的list右插入一个元素
	 * @param key 
	 * @param Vn 
	 * @returns 
	 */
	rpush(key: string, Vn: string): number;

	/**
	 * 执行一段lua脚本
	 * @param luaScript lua脚本字符串
	 * @param keys 脚本中的键参数
	 * @param values 键参数对应的值
	 *
	 * @example
	 * redisson.eval(`return redis.call('get', 'AAA: testSet')`)
	 */
	eval(luaScript: string, keys?: Array<any>, ...values: any): any;

	/**
	 * 获取list对应区间[start,end]对应的元素
	 * @param key 
	 * @param start 
	 * @param stop 
	 * @returns
	 */
	lrange(key: string, start: number, end: number): Array<any>;

	/**
	 * 返回key对应的value中下标为index的值
	 * @param key 
	 * @param index 
	 */
	lindex(key: string, index: number): string;

	/**
	 * 返回key对应的集合长度
	 * @param key 
	 */
	llen(key: string): number;

	/**
	 * 设置key对应的value中下标为index的值
	 * @param key 
	 * @param index 
	 * @param value 
	 */
	lset(key: string, index: number, value: any): void
}