# 数据库
# 导入
通过如下方式导入数据库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;
/**
* 返回一个创建表或者修复表的接口；
* @param conn
* @param tablename
* @return
*/
export function getTableCreator(conn: Connection, tableName: string): CreateTable;
/**
* 获取修改表结构的接口
* @param conn
* @param tablename
* @return
*/
export function getTableAlter(conn: Connection, tableName: string): AlterTable;# 对象
/**
* 数据源对象，通过此对象可以获取数据源相关属性、执行SQL。
*/
declare interface Datasource {
/**
* 返回数据源的名称
*/
getName(): string;
/**
* 返回Jdbc配置，可以参考JdbcSetting
*/
getJdbcConf(): DbConnectionInfo;
/**
* 返回默认的schema名称
*/
getDefaultSchema(): string;
/**
* 执行一个查询，并返回第一行数据的json（如果只是一个字段的话，直接返回字段的值）
*
* @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 };
/**
* 返回查询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. 此查询有最大10w行的数据限制，超过10w会有异常提示。
* 2. 查询会把结果装入内存，调用者需要注意可能的内存溢出。
* 3. 如果真有读取超过10w行数据的情况，不适合读取到内存，可以使用{@link #openTableData()#executeQueryExtractor()}方法，并设置合适的fetchSize参数执行查询。
*
* @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并返回查询结果，一个json数组
*
* @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的问号会用`params`中对应的值替换
* @param [limit] 行数限制，一个数字长度为1或2的数组，如：
* 1. `[5]`表示查询前5行
* 2. `[3, 5]`表示从第4行开始返回最多5行
* 3. 如果不传递，那么最多查询5万行，如果传递了，那么以传递的为准
* @param [params] 可选，sql中需要的参数值
* @returns 查询结果是数组的形式，每个元素是一个json，通过字段名获取字段的数据
*/
executePageQuery(sql: string, limit: number | number[], ...params: any): Array<{ [fieldName: string]: any }>;
/**
* 执行查询sql并返回查询结果，一个二维数组
*
* 注意：
* 1. 此查询有最大10w行的数据限制，超过10w会有异常提示。
* 2. 查询会把结果装入内存，调用者需要注意可能的内存溢出。
* 3. 如果真有读取超过10w行数据的情况，不适合读取到内存，可以使用{@link #openTableData()#executeQueryExtractor()}方法，并设置合适的fetchSize参数执行查询。
*
* @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的问号会用`params`中对应的值替换
* @param [params] 可选，sql中需要的参数值
* @returns 查询结果是二维数组的形式
*/
executeQueryRows(sql: string, params?: Array<any>): Array<Array<any>>;
/**
* 执行查询sql并返回查询结果，一个二维数组
*
* @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的问号会用`params`中对应的值替换
* @param [params] 可选，sql中需要的参数值
* @param [limit] 行数限制，一个数字长度为1或2的数组，如：
* 1. `[5]`表示查询前5行
* 2. `[3, 5]`表示从第4行开始返回最多5行
* 3. 如果不传递，那么最多查询5万行，如果传递了，那么以传递的为准
* @returns 查询结果是二维数组的形式
*/
executePageQueryRows(sql: string, limit: number | number[], ...params: any): Array<Array<any>>;
/**
* 将数据库表或是查询结果导出为csv|excel|dbf|szdb文件，如：`exportData({table:"DIM_BBQ",file:"/succez/exp"})`
*/
exportData(args: {
/**要导出的表名称 */
tableName?: string,
/**表所在的schema */
schema?: string,
/**如果没有指定表，那么必须指定sql */
sql?: string,
/**sql中的参数 */
params?: Array<any>,
/**导出到哪个文件 */
file: File | string,
/**文件格式，为空时自动从文件名中分析 */
fileType?: FileType,
/**csv文件的分隔符，默认逗号 */
separator?: string,
/**csv文件的编码，默认utf-8 */
encoding?: string,
/**日期的导出格式，默认 yyyy-MM-dd */
dateFormat?: string,
/**时间戳的导出格式，默认 yyyy-MM-dd HH:mm:ss */
timestampFormat?: string,
/**第一行是否是字段名，默认true */
firstRowIsFieldNames?: boolean,
/**是否只导出字段名(即不包含结构信息),默认为false */
titleOnlyField?: boolean
}): void;
/**
* 将csv|excel|dbf|szdb数据文件导入数据库表中
*
* @returns 返回导入后的返回信息，比如导入多少行、耗时多少等
*/
importData(args: {
/**要导入数据的表名称 */
tableName?: string,
/**要导入的csv文件，必须 */
file: File | string | InputStream,
/**文件格式，为空时自动从文件名中分析 */
fileType?: FileType,
/**导入模式，默认clear，表示清空目标表后导入新的数据 */
importMode?: DataImportMode;
/**csv文件的分隔符，默认逗号 */
separator?: string,
/**csv文件的编码，默认utf-8 */
encoding?: string,
/**日期的导出格式，默认自动识别 */
dateFormat?: string,
/**时间戳的导出格式，默认自动识别 */
timestampFormat?: string,
/**第一行是否是字段名，默认将自动识别 */
firstRowIsFieldNames?: boolean,
}): {
/**返回导入的表名 */
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(args: {
/**要导入数据的表名称 */
tableName?: string,
/**表描述 */
desc?: string,
/**表所在的schema */
schema?: string,
/**主键信息 */
primaryKeys?: Array<string>,
/**字段列表 */
fields: Array<TableFieldMetadata>,
}): void;
/**
* 判断表或视图是否存在
* @param tableName 表名或视图名
* @param [schema] 可选，schema名称，不传则在默认schema下进行查找
*/
isTableExists(tableName: string, schema?: string): boolean;
/**
* 返回数据源的元数据信息
*/
getMetaData(): DatasourceMetaData;
/**
* 返回表或视图的元数据信息
* @param tableName 表名或视图名
* @param [schema] 可选，schema名称
*/
getTableMetaData(tableName: string, schema?: string): TableMetaData;
/**
* 设置创建的TableData的自动提交方式，默认true。
* @warn 该方法不推荐使用，使用会导致ds内部的update方法不能提交。
* @param autoCommit
*/
setAutoCommit(autoCommit: boolean): void;
/**
* 返回一个能方便的对一个表进行查询或数据更新的工具对象
*
* @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;
/**
* 返回jdbc连接，连续多次调用此函数总是返回同一个连接对象，调用者需要负责关闭获取的连接对象。
*/
getConnection(): Connection;
/**
* 如果脚本里面要用字符串拼sql，那么用户输入的值要用formatConstValue转义之后再拼到sql里面去，防止出现sql注入漏洞
* 比如： "field like '"+ds.formatConstValue(value)+"'"
* "insert into testtb (field1,field2)value('aa','"+ds.formatConstValue(value)+"')
* @param str
*/
formatConstValue(str: string): string;
}
/**导入数据时的覆盖模式 */
declare const enum DataImportMode {
/** 新建一个表导入，目标表不存在则创建新表，存在则新建另一个表 */
NEWTABLE = "newTable",
/** 覆盖导入，如果目标表存在，会先执行删除 */
OVERWRITER = "overWriter",
/** 清空目标表，并导入新数据 */
CLEAR = "clear",
/** 追加导入，如果主键对应的数据存在则忽略 */
APPEND = "append",
/** 更新导入，不存在的追加，存在的覆盖 */
MERGE = "merge",
/** 直接导入，不做任何判断 */
INSERT = "insert"
}
/** 导入导出数据文件格式 */
declare const enum FileType {
CSV = 'csv',
SZDB = 'szdb',
DBF = 'dbf',
XLS = 'xls',
xlsx = 'xlsx'
}
/**
* 根据一个表的主键等信息，提供比较方便的查询和修改一个表的数据的工具对象。
* 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 {
/**
* 执行一个查询，并返回第一行数据的json
*
* @param columnNames 要查询的字段，如:`"*"`, `"FIELD1"`, `["FIELD1", "FIELD2"]`
* @param [where] 查询条件，可以是一个字符串，如`"FIELD1=123 AND FIELD2='abc'"`，也可以是一个json，如`{"FIELD1":123, "FIELD2":"abc"}`
* @param [orderBy] 排序字段 传一个字符串 如`"FIELD1 DESC FIELD2 ASC"`
* @returns 当参数`columnNames`只是一个字符串字段时，返回的结果就是字段值，如果是多个字段那么返回一个json对象，key是字段名，
* 当数据不存在时返回`null`
*/
selectFirst(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, orderBy?: string): { [fieldName: string]: 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] 排序字段 传一个字符串 如`"FIELD1 DESC FIELD2 ASC"`
* @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] 排序字段 传一个字符串 如`"FIELD1 DESC FIELD2 ASC"`
* @returns 当参数`columnNames`只是一个字符串字段时，返回的结果就是字段值，如果是多个字段那么返回一个数组，
* 当数据不存在时返回`null`
*/
selectFirstRow(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, orderBy?: string): Array<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] 排序字段 传一个字符串 如`"FIELD1 DESC FIELD2 ASC"`
* @returns 返回一个二维数组，如果没有满足条件的额数据，返回空数组
*/
selectRows(columnNames: string | Array<string>, where?: string | { [fieldName: string]: any }, limit?: number | number[], orderBy?: string): Array<Array<any>>;
/**
* 执行查询sql并返回查询结果，一个json数组
*
* @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的问号会用`params`中对应的值替换
* @param [params] 可选，sql中需要的参数值
* @returns 查询结果是数组的形式，每个元素是一个json，通过字段名获取字段的数据
*/
executeQuery(sql: string, params?: Array<any>): Array<{ [fieldName: string]: any }>;
/**
* 执行查询sql并通过一个回调函数resultSetExtractor自己处理结果集。
*
* 注意：
* 1. 调用此方法需要设置合适的fetchSize参数。
* 2. 如果需要读取所有数据，可以将maxRows设置为-1。
*
* 用于：
* 1. 导出数据到文件。
*
* @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的问号会用`params`中对应的值替换
* @param [resultSetExtractor] 必选，此回调函数有一个参数resultSet，是数据库结果集遍历器，不需要调用close。
* @param [params] 可选，sql中需要的参数值
* @returns 返回回调函数resultSetExtractor的返回值。
*/
executeQueryExtractor(sql: string, resultSetExtractor: (resultSet: JdbcResultSet) => any, params?: Array<any>): any;
/**
* 执行查询sql并返回查询结果，一个二维数组
*
* @param sql 要查询的SQL，应该是一个select语句，如 `select * from mytable where id＝?` ，其中的问号会用`params`中对应的值替换
* @param [params] 可选，sql中需要的参数值
* @returns 查询结果是二维数组的形式
*/
executeQueryRows(sql: string, params?: Array<any>): 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 返回插入的行数
*/
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;
/**
* 删除所有数据行
*/
deleteAll(): void;
/**
* 清空表数据，不可回滚
*/
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;
/**
* 执行一个update或ddl语句，返回影响的行数
*
* @param sql update或ddl语句
* @param [params] 可选，sql中需要的参数值
* @returns 返回影响的行数
*/
executeUpdate(sql: string, params?: Array<any>): number;
/**
* 将表数据导出为csv文件，如：`exportData({file:"/succez/exp"})`
*/
exportData(args: {
/**导出到哪个文件 */
file: File | string,
/**csv文件的分隔符，默认逗号 */
separator?: string,
/**csv文件的编码，默认utf-8 */
encoding?: string,
/**日期的导出格式，默认 yyyy-MM-dd */
dateFormat?: string,
/**时间戳的导出格式，默认 yyyy-MM-dd HH:mm:ss */
timestampFormat?: string,
/**第一行是否是字段名，默认true */
firstRowIsFieldNames?: boolean,
}): void;
/**
* 将csv数据文件导入数据库表中
*
* @returns 返回导入后的返回信息，比如导入多少行、耗时多少等
*/
importData(args: {
/**要导入的csv文件，`file`和`data`，必须传递其一 */
file?: File | string,
/**要导入的数据，二维数组形式，`file`和`data`，必须传递其一 */
data?: any[][];
/**导入模式，默认clear，表示清空目标表后导入新的数据 */
importMode?: DataImportMode;
/**csv文件的分隔符，默认逗号 */
separator?: string,
/**csv文件的编码，默认utf-8 */
encoding?: string,
/**日期的导出格式，默认自动识别 */
dateFormat?: string,
/**时间戳的导出格式，默认自动识别 */
timestampFormat?: string,
/**第一行是否是字段名，默认将自动识别 */
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;
/**
* 设置一次查询最多读取的数据行。
*
* 用于：
* 1. 当需要读取超过10w行数据时，比如导出数据到文件，调用此方法限制范围。
* 2. 如果需要读取全部数据，可以设置-1，表示不限制。
* 3. 并设置合适的fetchSize，特别是mysql，避免oom。
*
* 不设置时，默认最多读取10w行。
*
* @param maxRows
*/
setMaxRows(maxRows: number): void;
/**
* 设置查询时，每次从数据库获取一批数据的行数。
*
* 注意：
* 1. 这是jdbc参数，用于需要读取所有数据时，比如读取到文件。
* 2. mysql需要特别注意，读取大的结果集，必须设置此参数。
*
* 不设置，将使用驱动的默认值。
*
* @param fetchSize
*/
setFetchSize(fetchSize: number): void;
/**
* 提交所做的修改。只有当`Datasource`的`autoCommit`是`false`（默认是`false`）时,并且连接对象是内部生成的，才需要主动调用此函数提交数据。
* @warn 该方法仅用于内部conn且autoCommit=false的时候调用，请勿在外部传入conn是调用，外部传入conn时需要使用者自己管理。
*/
commit(): void;
/**
* 回滚所做的修改。
* @warn 同commit()方法一样，请不要在外部传入conn时调用。
*/
rollback(): void;
/**
* 增加的close方法。
* 当自己获取的连接，且设置了autoCommit=false，在finally块调用，防止连接漏洞。
*/
close(): void;
}
/**
* 数据库的元数据信息
*/
declare interface DatasourceMetaData {
/**
* 数据库类别
*/
getDbType(): DbType;
/**
* 主版本号
*/
getDatabaseMajorVersion(): number;
/**
* 副版本号
*/
getDatabaseMinorVersion(): number;
/**
* 数据库完整的版本号
*/
getDatabaseProductVersion(): string;
/**
* 完整的数据库名
*/
getDatabaseProductName(): string;
/**
* 获取jdbc驱动的版本号
*/
getDriverVersion(): string;
/**
* 获取jdbc驱动的主版本号
*/
getDriverMajorVersion(): number;
/**
* 返回schema列表
* @returns 没有任何结果时返回空数组（不是null）
*/
getSchemas(): string[];
/**
* 返回所有的表、视图或同义词。
*
* @returns 返回查询的结果，如果没有任何表或视图，那么返回空数组（不是null）
*/
getTables(args: {
/**
* 数据库的schema、对mysql等价于database、对oracle等价于user，不传递时，查询默认schema的表。*/
schema?: string,
/**
* 查询哪些类型的表，默认只查询表，不查询视图和同义词。
*/
types?: TableType[],
/**
* 强制重新查询数据库，不使用缓存。默认false，使用缓存。
*/
forceReload?: boolean,
}): TableMetaData[];
}
/**
* 表或视图的元数据信息
*/
declare interface TableMetaData {
/**
* 表名称
*/
getName(): string;
/**
* 返回表描述信息
*/
getComment(): string;
/**表类型，物理表或视图 */
getType(): TableType;
/**
* 返回带scheme的完整名字
*/
getFullTableName(): string;
/**
* 返回所属的schema
*/
getSchema(): string;
/**
* 返回全部字段列表
*/
getColumns(): Array<TableFieldMetadata>;
/**
* 返回索引列表
*/
getIndices(): Array<TableIndexMetadata>;
/**
* 返回表主键
*/
getPrimaryKey(): Array<string>;
/**
* 返回创建表的ddl
*/
getDDL(): string;
/**
* 返回数据表所占空间大小
*/
getStorageSize(): number;
/**
* 返回数据表数据行数
*/
getRowCount(): number;
}
/**表类型 */
declare const enum TableType {
/**物理表 */
table = "table",
/**视图 */
view = "view",
/**同义词 */
synonym = "synonym",
}
/**字段元数据信息 */
declare interface TableFieldMetadata {
/**
* 唯一id。
*/
name: string;
/**
* 字段描述。
*/
desc?: string;
/**
* 字段类型.
*/
dataType: FieldDataType;
/**
* 字段长度，字符型、整形、浮点型字段有此属性。
*/
length?: number;
/**
* 小数位数，浮点型字段有此属性。
*/
decimal?: number;
/**
* 是否允许为空
*/
nullable?: boolean;
/**
* 字段在表中的位置，即是第几个字段
*/
index?: number;
}
/**
* 数据表索引信息
*/
declare interface TableIndexMetadata {
/**
* 索引名。
*/
name: string;
/**
* 是否唯一索引。
*/
unique?: boolean;
/**
* 索引字段列表，列表中存放的是字段的物理字段名。
*/
fields: Array<string>;
/**
* 字段的排序方式，默认每个字段的排序方式为升序
*/
sorts?: { [name: string]: string };
}
/**
* 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;
/**
* 批量产生一批序列号，性能比多次调用{@link #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, ...field: 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
}
/**导入数据时的覆盖模式 */
declare const enum AlterTableMode {
/**
* alter优先模式<br>
* 此模式将通过执行一系列alter语句实现目的；<br>
* 此模式适用于源表数据量小的时候。<br>
* 默认使用此模式；<br>
* 注意此模式是不可逆的，一旦执行，不能取消。
*/
MODE_ALTER = 0,
/**
* 临时表模式<br>
* 此模式将通过创建临时表，来实现目的；<br>
* 原理：使用新字段属性创建临时表，copy数据到临时表，源表更名，临时表更名为原表名，删除更名后的源表；<br>
* 此模式适用于源表有大量数据的时候。
*/
MODE_TEMPTABLE = 1
}
declare interface AlterTable {
/**
* 修改字段名
* @param columnName
* @param newcolumnName
*/
modifyColumnName(columnName: string, newcolumnName: string): void;
/**
* 修改字段长度，对字符类型字段有效；
* @param columnName
* @param len
*/
modifyColumnLength(columnName: string, len: number): void;
/**
* 修改数值类型精度
* @param columnName
* @param len 总长度
* @param scale 小数位数
*/
modifyColumnPrecision(columnName: string, len: number, scale: number): void;
/**
* 更改字段类型、长度、精度
* @param columnName
* @param coltype {@link ColumnTypes}
* @param len
* @param scale
*/
modifyColumn(columnName: string, coltype: string, len: number, scale: number): void;
/**
* 更改字段值是否能为空；
* @param columnName
* @param nullable
*/
modifyColumnNullable(columnName: string, nullable: boolean): void;
/**
* 更改字段的唯一属性
* @param columnName
* @param unique
*/
modifyColumnUnique(columnName: string, unique: boolean): void;
/**
* 更改字段默认值；
* @param columnName
* @param defvalue
*/
modifyColumnDefaultValue(columnName: string, defvalue: string): void;
/**
* 修改字段描述
* @param columnName
* @param comment
*/
modifyColumnComment(columnName: string, comment: string): void;
/**
* 修改表的描述
* @param comments
*/
modifyTableComment(comment: string): void;
/**
* 修改字段的自增长属性
* @param columnName
* @param autoInc
*/
modifyAutoInc(columnName: string, autoInc: boolean): void;
/**
* 增加一个字段；
* @param columnName
* @param coltype {@link com.succez.commons.jdbc.ColumnTypes}
* @param len
* @param scale
* @param defvalue
* @param nullable
* @param unique
*/
addColumn(columnName: string, coltype: string, len: number, scale: number, defvalue: string, nullable: boolean, comment: string): void;
/**
* 增加一个字段，带是否唯一属性
* @param columnName
* @param coltype
* @param len
* @param scale
* @param defvalue
* @param nullable
* @param unique 唯一属性
* @param comment
*/
addColumn(columnName: string, coltype: string, len: number, scale: number, defvalue: string, nullable: boolean, unique: boolean, comment: string,
autoInc: boolean): void;
/**
* 删除字段
* @param columnName
*/
dropColumn(columnName: string): void;
/**
* 设置新的主键
* @param keys 如果keys==null,则表示删除现有主键
*/
setPrimaryKey(keys: string[]): void;
/**
* 删除现有主键
*/
dropPrimaryKey(): void;
/**
* 删除索引
* @param indexName
*/
dropIndex(indexName: string): void;
/**
* 增加索引
* @param columns
* @param unique
*/
addIndex(columns: string[], unique: boolean): void;
/**
* 定义索引，自定索引名。
* @param indexName
* @param fields
* @param unique
*/
addIndex(indexName: string, fields: string[], unique: boolean): void;
/**
* 定义索引，自定索引名。
* @param indexName
* @param fields
* @param unique
*/
addIndex(indexName: string, fields: string[], unique: boolean, sorts: { [k: string]: string }): void;
/**
* 20131122 dw
* 执行修改表前，获得新的修改设置后的表结构。
* 此方法实时生成，每次调用都新建一个对象返回。
* @return
* @throws SQLException
*/
getNewTableMetaData(): TableMetaData;
/**
* 返回修改前，数据表的结构。
* @return
* @throws SQLException
*/
getSourceTableMetaData(): TableMetaData;
/**
* 修改字段的实现模式
* 默认使用alter模式
* @param mode
*/
setModifyMode(mode: number): void;
/**
* 20131122 dw
* 在临时表模式下，是否删除原表。
* 默认是删除。
* @param isdelete
*/
isDeleteOldTableOnTempModel(isdelete: boolean): void;
/**
* 20131122 dw
* 在临时表模式下，如果设置了不删除原表，那么返回更名后的原表名。
* @return
*/
getOldTableName(): string;
/**
* 初始化状态，清除先前所做的修改字段的信息；
*/
clear(): void;
/**
* 批量提交字段修改；
* @throws SQLException
*/
commit(): void;
/**
* 遍历执行修改的所有ddl<br>
* 执行commit后调用。
* @param i
* @return
*/
getDDL(i: number): string;
/**
* 返回需要执行的所有ddl的个数；<br>
* 执行commit后调用。
* @return
*/
getDDLCount(): number;
}
declare interface CreateTable {
/**
* 设置是否创建临时表。
* 1.临时表只存在于当前会话中，不同的会话，可以使用同名临时表。
* 2.创建的临时表（conn调用close时）会自动回收。
* 3.临时表不会影响数据库的全局表列表。
*
* 当需要在一个操作事务中，创建一个临时表读写数据，且事物完成后不再需要它时，推荐使用临时表。
* @param isTempTable
*/
setCreateTempTable(isTempTable: boolean): void;
/**
* 清除定义的表结构
*/
clear(): void;
/**
* 定义表名
* @param tablename
*/
setTableName(tablename: string): void;
/**
* 定义表注释
* @param comment
*/
setTableComment(comment: string): void;
/**
* 是否允许自动更更改表名；
* 当指定的表名被占用时，起作用；
* 默认值是false
* @param f
*/
setAutoChangeTableName(f: boolean): void;
/**
* 是否允许自动调整字段的长度；
* 根据数据库的限制，自动调整字段长度，比如：主键列组合长度超过限制等；
* 默认值是false
* @param f
*/
setAutoAdjustFieldLength(f: boolean): void;
/**
* 定义自增长字段
* @param fieldname
*/
addAutoIncColumn(fieldname: string): void;
/**
* 定义自增长字段
* @param fieldname
* @param comments 字段注释
*/
addAutoIncColumn(fieldname: string, comments: string): void;
/**
* 定义整型字段
* @param fieldname
*/
addIntegerColumn(fieldname: string, len: number): void;
/**
* 定义整型字段
* @param fieldname
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addIntegerColumn(fieldname: string, len: number, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 增加唯一属性
* @param fieldname
* @param defaultvalue
* @param nullable
* @param unique
* @param comments
*/
addIntegerColumn(fieldname: string, len: number, defaultvalue: string, nullable: boolean, unique: boolean, comments: string): void;
/**
* 定义字符类型字段
* @param fieldname
* @param len
*/
addVarcharColumn(fieldname: string, len: number): void;
/**
* 定义字符类型字段
* @param fieldname
* @param len
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addVarcharColumn(fieldname: string, len: number, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 增加唯一属性
* @param fieldname
* @param len
* @param defaultvalue
* @param nullable
* @param unique
* @param comments
*/
addVarcharColumn(fieldname: string, len: number, defaultvalue: string, nullable: boolean, unique: boolean, comments: string): void;
/**
* 定义浮点类型字段
* @param fieldname
* @param len 精度，如果精度<=0，表示不能确定字段精度，将定义为无精度的浮点类型，支持任意的精度。
* @param scale 小数位数
*/
addNumericColumn(fieldname: string, len: number, scale: number): void;
/**
* 定义浮点类型字段
* @param fieldname
* @param len 精度，如果精度为0，表示不知道该字段精度，将定义为无精度的浮点类型。
* @param scale 小数位数
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addNumericColumn(fieldname: string, len: number, scale: number, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 增加唯一属性
* @param fieldname
* @param len
* @param scale
* @param defaultvalue
* @param nullable
* @param unique
* @param comments
*/
addNumericColumn(fieldname: string, len: number, scale: number, defaultvalue: string, nullable: boolean, unique: boolean, comments: string): void;
/**
* 定义日期类型
* @param fieldname
*/
addDateColumn(fieldname: string): void;
/**
* 定义日期类型
* @param fieldname
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addDateColumn(fieldname: string, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 增加唯一属性
* @param fieldname
* @param defaultvalue
* @param nullable
* @param unique
* @param comments
*/
addDateColumn(fieldname: string, defaultvalue: string, nullable: boolean, unique: boolean, comments: string): void;
/**
* 定义timestamp字段
* @param fieldname
*/
addTimestampColumn(fieldname: string): void;
/**
* 定义timestamp字段
* @param fildname
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addTimestampColumn(fildname: string, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 定义clob字段
* @param fieldname
*/
addClobColumn(fieldname: string): void;
addClobColumn(fieldname: string, comments: string): void;
/**
* 定义bolb字段
* @param fieldname
*/
addBlobColumn(fieldname: string): void;
addBlobColumn(fieldname: string, comments: string): void;
/**
* 定义字段，使用java.sql.Types定义字段类型
* @param fieldname
* @param type {@link java.sql.Types} 定义的字段类型
* @param len
* @param scale
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addColumnWithSqlTypes(fieldname: string, type: number, len: number, scale: number, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 增加唯一属性
* @param fieldname
* @param type
* @param len
* @param scale
* @param defaultvalue
* @param nullable
* @param unique
* @param comments
*/
addColumnWithSqlTypes(fieldname: string, type: number, len: number, scale: number, defaultvalue: string, nullable: boolean, unique: boolean, comments: string): void;
/**
* 定义字段
* @param fieldname
* @param coltype {@link com.succez.commons.jdbc.ColumnTypes} 定义的字段类型
* @param len
* @param scale
* @param defaultvalue
* @param nullable
* @param comments 字段注释
*/
addColumn(fieldname: string, coltype: string, len: number, scale: number, defaultvalue: string, nullable: boolean, comments: string): void;
/**
* 增加唯一属性
* @param fieldname
* @param coltype
* @param len
* @param scale
* @param defaultvalue
* @param nullable
* @param unique
* @param comments
*/
addColumn(fieldname: string, coltype: string, len: number, scale: number, defaultvalue: string, nullable: boolean, unique: boolean, comments: string): void;
/**
* 定义主键
* @param keys
*/
setPrimaryKey(keys: string[]): void;
/**
* 定义索引
* @param fields
* @param unique
*/
addIndex(fields: string[], unique: boolean): void;
/**
* 定义索引，自定索引名。
* @param indexName
* @param fields
* @param unique
*/
addIndex(indexName: string, fields: string[], unique: boolean): void;
/**
* 定义索引，自定索引名和字段排序顺序。
* @param indexName
* @param fields
* @param unique
*/
addIndex(indexName: string, fields: string[], unique: boolean, sorts: { [k: string]: string }): void;
/**
* 创建表，返回表名
* @return
*/
createTable(): string;
/**
* 如果指定的表不存在，则创建表；
* 否则，修改表结构，使表结构和定义的结构一致；
* 返回执行修改语句的条数。
* @return
*/
repairTable(): number;
/**
* 修改表结构指定修改模式<br>
* {@link AlterTable#MODE_ALTER}时，返回执行修改语句的条数。
* @param mode {@link AlterTable#MODE_ALTER}, {@link AlterTable#MODE_TEMPTABLE}
* @throws SQLException
*/
repairTable(mode: number): number;
}
是否有帮助？
0条评论
评论