比特派官方安卓下载app|qb查询
作者： 比特派官方安卓下载app
2024-03-07 20:44:33
首页 - 腾讯充值中心
首页 - 腾讯充值中心
手机版
手机版
欢迎光临！
登录
欢迎您，
退出
手机版
欢迎光临！登录
iOS手游充值
更多>>
游戏点券充值
更多>>
DNF点券
CF点券
英雄联盟
无畏契约
逆战点券
QQ炫舞2
服务开通
更多>>
腾讯视频
QQ会员
黄钻贵族
绿钻豪华版
QQ阅读
微云会员
Copyright © 1998 - 2024 Tencent. All Rights Reserved
腾讯公司 版权所有 服务条款
隐私政策
查询Q币交易记录和消费情况
查询Q币交易记录和消费情况
腾讯客服
服务记录查询
退出
登录
请您登录账户！
让我们为您提供更多贴心服务
随便逛逛
查询Q币交易记录和消费情况
Q币消费记录查询方式：请到腾讯充值中心->我的账户->交易明细->输入查询日期范围->查询即可 温馨提示：1、若Q币中有消费记录，但不是您自己使用的，建议尽快修改您的QQ密码，可能是密码外泄导致他人去消费使用；2、当天的消费记录若未查看到，建议在第二天查询，因为数据会有一个更新的过程。
小Q是腾讯客服专家，同时也是本帮助页面的作者。请在下方提供反馈，以帮助她优化内容。
以上信息是否解决了您的问题？
是
否
感谢您提供反馈
感谢您的反馈，我们将持续优化！
请选择未解决的原因
描述不清晰
对产品功能不满意
内容不正确
操作后未能解决问题
关注微信公众号
向腾讯客服提问
腾讯服务专线
4006 700 700
财付通/微信支付/理财通服务专线
95017（大陆地区） +86 571 95017（海外及港澳台地区）
理财通服务专线
95788
未成年人游戏监管专线
95092666
关于腾讯
about Tencent
服务条款
腾讯充值中心
腾讯充值中心
充值中心LOGO
欢迎光临！登录
首 页
Q点充值
服务开通
Q币Q点保护
我的帐户
查询帐户余额
{%#tmp data%}
QQ帐户：
{%data.qb_balance%}
Q币开通服务
{%data.qd_balance%}
Q点充Q币/Q点
QQ积分：
{%data.jf_balance%}
积分
{%/#tmp%}
数据加载中，请稍候……
验证码：
{%#tmp data%} {%data.errorInfo%}{%/#tmp%}
看不清换一张
查询交易明细
任意时段内的Q点/Q币交易明细
QQ卡交易明细
查询您的QQ卡交易记录
我开通的服务
查询并管理您开通的所有服务
设置消费限额
设置您的Q点Q币消费限额
账户充值 - 腾讯充值中心
账户充值 - 腾讯充值中心
手机版
欢迎光临！登录
正在加载，请稍后……
您当前位置：... >
您的订单号 ：,已成功提交(请注意保存订单号)!
购买结果会有延时，您可以点击下面“查询结果”链接查询
查询中
查询结果
系统扣费成功，24小时内到账，感谢您的支持。
您的订单号 ：
系统正在处理中，您的订单号 ：
购买结果会有延时，您可以点击下面“查询结果”链接查询
查询中
查询结果
系统扣费失败，请重新充值，或选择其它充值方式，感谢您的支持。
您的订单号 ：
继续充值
更多详情>>
开通服务：
元/月
开通帐户：
开通时长：
应付金额：
确认开通
修改订单
重新支付
月服务期限：开通当日起31天
同意 服务条款
必须同意以上条款才能开通
向好友索要>>
客服帮助
您当前服务状态
尊敬的()用户， 给充值可享当月累计不超过 Q币的折优惠！(仅限QQ钱包)
尊敬的用户，梦网短信开通的QQ会员暂时不享受充值Q币优惠。
开通服务：
开通帐号：
赠送好友
付费模式：
升级
按月付费
按年付费
游戏大区：
加载中...
开通时长：
月
开通方式：
加载中，请稍候……
温馨提示
Copyright © 1998 - 2024 Tencent. All Rights Reserved
腾讯公司 版权所有 服务条款
隐私政策
×
您好！
×
温馨提示
百度知道 - 信息提示
百度知道 - 信息提示
百度首页
商城
注册
登录
网页
资讯
视频
图片
知道
文库
贴吧采购
地图更多
搜索答案
我要提问
百度知道>提示信息
知道宝贝找不到问题了>_
该问题可能已经失效。返回首页
15秒以后自动返回
帮助
| 意见反馈
| 投诉举报
京ICP证030173号-1 京网文【2023】1034-029号 ©2024Baidu 使用百度前必读 | 知道协议
如何查询Q币到账情况及余额？
如何查询Q币到账情况及余额？
腾讯客服
服务记录查询
退出
登录
请您登录账户！
让我们为您提供更多贴心服务
随便逛逛
如何查询Q币到账情况及余额？
充值Q币查询到账情况可登录http://pay.qq.com/->我的服务->查询交易明细下详细了解您的Q币余额、到账及消费情况。翻译搜索复制
小Q是腾讯客服专家，同时也是本帮助页面的作者。请在下方提供反馈，以帮助她优化内容。
以上信息是否解决了您的问题？
是
否
感谢您提供反馈
感谢您的反馈，我们将持续优化！
请选择未解决的原因
描述不清晰
对产品功能不满意
内容不正确
操作后未能解决问题
关注微信公众号
向腾讯客服提问
腾讯服务专线
4006 700 700
财付通/微信支付/理财通服务专线
95017（大陆地区） +86 571 95017（海外及港澳台地区）
理财通服务专线
95788
未成年人游戏监管专线
95092666
关于腾讯
about Tencent
服务条款
查询Q币余额方法 - 腾讯客服
查询Q币余额方法 - 腾讯客服
查询Q币余额方法
查询Q币余额，请使用手机QQ关注“腾讯充值”公众号，点击底部菜单【我的账户】->【我的余额】，即可查看个人账户Q币的余额。搜索复制
已解决
未解决
已解决
未解决
已解决
未解决
未解决原因（最多可选二项）
描述不清晰
操作后未解决
规则不合理
功能不好用
其它原因 »
相关问题
未解决还需要
联系客服
联系客服
您可能还需要
意见反馈
问题与原因
联系手机
提交
请您关注腾讯客服微信，以便正常使用该服务
取消确定
您已提交过该问题，无需重复提交，客服人员正在为您处理，请您耐心等待并留意腾讯客服公众号的消息通知，谢谢！
查看问题
服务授权
您需要填写一些信息方便我们解答，提交成功后，我们会通过微信客户端“腾讯客服”公众号联系您，请您确认：
授权
返回
服务授权
为了更好的解决您的问题，现需要通过【微信“腾讯客服”公众号】向您采集部分问题信息，请确认是否授权：
授权
返回
恭喜授权成功
授权成功，请您切换至微信提交问题相关信息，提交成功后我们将通过微信客户端“腾讯客服”公众号将处理结果答复给您。
返回
温馨提醒
您之前提交的问题已收到，我们会通过微信客户端“腾讯客服”公众号联系您，请您打开微信接收消息。
我知道了
温馨提醒
您之前提交的问题正在处理中，请耐心等待答复，我们将会在24小时内通过微信客户端“腾讯客服”公众号答复您的问题，请您耐心等待。
我知道了
温馨提醒
您好，在线服务时间为09：00-21：30，建议您通过我们的帮助专区自助解决您的问题，或者在明天工作时间（09：00-21：30）再来咨询，谢谢！
返回
温馨提醒
访问失败，请您检查网络后重新提交，谢谢。
返回
提交成功
感谢您的反馈，我们将不断优化内容以便为您提供更优质的服务，谢谢！
3秒后本页自动关闭
正在加载
QB查询 - 腾讯应用中心
QB查询 - 腾讯应用中心
跳到内容区
QQ空间6.0
个人中心
我的主页
应用
想看高清影视，想玩好友热应用，更多精彩
立即登录体验
QB查询
搜索
搜索
当前位置：首页>游戏>QB查询
QB查询
游戏|陈邵奇
QB查询是在腾讯平台运营的一款应用
同意：应用用户协议以及更多
进入应用
温馨提示：按照国家政策要求，游戏需实名注册，为了您更畅快的体验，请您及时注册。立即注册
本应用获取我的昵称、头像、好友关系等相关信息；
在我的其他相关腾讯服务中自动同步添加本应用及数据；
本应用和腾讯使用我添加、操作应用的信息(包括昵称、头像等)。
.
界面预览
喜欢此应用的人还喜欢：
斗武ol
游戏
0.0
战士三国
游戏
0.0
七雄争霸
游戏
0.0
本周热门推荐：
本周上升最快：
友情链接
空间应用
小游戏
网页游戏
腾讯开放平台
腾讯社区开放平台
黄钻贵族 | 官方Qzone | 官方微博 | 腾讯互联 | 开放平台 | 腾讯博客 | 腾讯客服 | 应用侵权投诉 | Complaint Guidelines | 粤网文[2011]0483-070号
Copyright © 1998 - 2015 Tencent.All Rights Reserved.
腾讯公司 版权所有
一款小巧又强大的神器 —— qb-mysql - 知乎
一款小巧又强大的神器 —— qb-mysql - 知乎首发于巨人的肩膀切换模式写文章登录/注册一款小巧又强大的神器 —— qb-mysql还没想好文艺到没人要的程序狗qb-mysql是一款 服务于mysql的 query builder 工具，其通过链式调用的方式将结构化数据组装成用于mysql的查询对象。qb-mysql 不仅体积非常小巧，而且功能十分强大，API丰富多样，可以轻松应对企业级的应用开发 背景日常server开发中，在处理表关系稍微复杂的应用时，或做查询性能优化时，使用ORM工具库处理关联表会稍显捉襟见肘，这些时候会发现裸写sql更舒适，更便捷。但裸写sql一旦犯懒就很可能埋下注入的坑。虽然 mysql js 提供了 escaping-query-values 和 escaping-query-identifiers 的方式，但你依旧可能会使用这种 select a.name, a.score, b.name from tableA a inner join TableB b on a.bId = b.id where a.id=${aId} and b.id=${bId} 懒惰但快捷的方式拼接你的query语句。因为写成防止注入的版本escape版，需要写更多重复的代码，如下const aId = 1
const bId = 1
const sql = 'select ??.??, ??.??, ??.?? from ?? ?? inner join ?? ?? on ??.?? = ??.?? where ??.?? = ? and ??.?? = ?'
const values = ['a', 'name', 'a', 'score', 'b', 'name', 'tableA', 'a', 'tableB', 'b', 'a', 'bId', 'b', 'id', 'a', 'id', aId, 'b', 'id', bId]
写起来是不是很崩溃，尤其是复杂些的查询场景，sql语句非常长，escape的字段不仅多，而且重复度很高，看的眼都花了。这种情况下，使用 就可以轻松搞定了安装与使用安装npm i -S qb-mysql引入const Querybuilder = require('qb-mysql')
使用const aId = 1
const bId = 1
const qb = new Querybuild()
qb.select({ tableA: ['name', 'score'], tableB: ['name'] })
.from('tableA')
.innerJoin('tableB', { id: bId })
.where({ tableA: { id: aId }, tableB: { id: bId } })
connection.query(...qb.toQuery())
// 生成的sql语句为
// console.log(mysql.format(...qb.toQuery()))
// select `tableA`.`name`, `tableB`.`score`, `tableB`.`name` from `tableA`
// inner join `tableB` on `tableB`.`id` = `tableA`.`bId` where `tableA`.`id` = 1 and `tableB`.`id` = 1
APIselectcount max min avg sumfromjoinwhereorderpage limit offsetgroup byinsertupdatedeletesub padEndselect参数类型 type field = string | number | boolean type cb = (qb: queryBuilder, tableName?: string) => queryBuilder | { sql: string, values: any[] } | void type renane = string + type asArr = [field, rename] type fieldArr = (field | asArr | cb)[] type asObj = { [key: string]: rename } type fieldObj = asObj | { [key: string]: cb } type table = { tableName: valObj | valArr | cb }函数列表说明select(params: field) => qb单个字段select(params: fieldArr | fieldObj) => qb多个字段select(params: table) => qb字段中带表名，支持多个表select(params: cb) => qb使用函数，参数是一个新的queryBuilder对象，返回值可有可无例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 单个字段，如果是字符串则认为是字段，数字或布尔则认为是值
qb.select('a') // => select `a`
qb.select(1) // => select 1
qb.select() // => select * // 空字符串，null，undefined返回 *
// 多个字段, 可以用对象，也可以用数组，嵌套数组使用as，对象也使用as
qb.select(['a', 'b']) // => select `a`, `b`
qb.select([['a', 'r']]) // => select `a` as `r`
qb.select({ a: 'ra', b: 'rb' }) // => select `a` as `ra`, `b` as `rb`
qb.select({}) // => select * // 空对象，空数组返回 *
// 带表名，使用对象，多个表则使用多组kv，value值类型同多个值的类型
qb.select({ t: ['a'] }) // => select `t`.`a`
qb.select({ t1: { a: 'ra' }, t2: [['a', 'ra'], 'b'] }) // => select `t1`.`a` as `ra`, `t2`.`a` as `ra`, `t2`.`b`
qb.select({ t: [] }) // => select `t`.* // value是空值时返回 *
// 静态类型不够用，也可以使用函数，
// 第一个参数是一个新的queryBuilder对象，非箭头函数也可以使用this，不用参数，在一些场景中有第二参数tableName
// 返回值可以是{ sql: string, values: any[] }类型的对象，也可以没有，如果没有则使用queryBuilder对象
qb.select({ min: qb => qb.min('a') }) // => select min(`a`)
qb.select([() => ({ sql: 'max(??) as ??', values: ['a', 'maxA'] }), 'b']) // => select max(`a`) as `maxA`, `b`
qb.select({ t: { avg(qb, tableName) { this.avg([tableName, 'a'], 'a') }, b: 'b' } }) // => select avg(`t`.`a`) as `a`, `t`.`b` as `b`
count max min avg sum参数类型 type name = string type tableName = string函数qb-mysql只内置了count, max, min, avg, sum 这几个常用的函数，且一般要配合select的子函数使用列表说明count(as?: name) => qb无max(field: name, as?: name) => qb无min(field: name, as?: name) => qb无avg(field: name, as?: name) => qb无sum(field: name, as?: name) => qb无max([tableName, name], as?: name) => qb表名min([tableName, name], as?: name) => qb表名avg([tableName, name], as?: name) => qb表名um([tableName, name], as?: name) => qb表名例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 单个字段，如果是字符串则认为是字段，数字或布尔则认为是值
qb.count('count') // => count(*) as count
qb.avg('a') // => avg(`a`)
qb.max('a', 'maxA') // => max(`a`) as `maxA`
qb.min(['t', 'a'], 'min') // => min(`t`.`a`) as `min`
qb.select((sub) => sub.sum('a', 'sum')) // => select sum(`a`) as `sum`
from参数类型 type name = string函数列表说明from(tableName: name, rename?: name) => qb无例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 单个字段，如果是字符串则认为是字段，数字或布尔则认为是值
qb.from('t') // => from `t`
qb.from('t', 'r') // => from `t` `r`
join参数类型 type name = string + type targetTableKey = string type sourceTableKey = string type mapping = { [key: targetTableKey]: sourceTableKey }函数包含join, innerJoin, leftJoin, rightJoin, crossJoin, outerJoin，当使用join函数时参数列表多最后一个prefix参数，可以用于添加join前的修饰词，以弥补内置函数不够用的情况列表说明from(sourcetable: name).join(targetTable: name, mapping: mapping) => qb配合from一起使用，使用前两个参数即可，如果要指定prefix，则需要补齐4个参数join(targetTable: name, mapping: mapping, sourceTabel: name, prefix?: string) => qb独立使用，需要第三个参数join(params: { target: name, mapping: mapping, source: name }, prefix?: string) => qb独立使用，第一个参数使用object类型例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 配合from使用
qb.from('t1').join('t2', { t1_id: 'id' }) // => from `t1` join `t2` on `t2`.`t1_id` = `t1`.`id`
// 独立使用，一般是多表联合
qb.from('t1').join('t2', { t1_id: 'id' }).join('t3', { t2_id: id }, 't2')
// => from `t1` join `t2` on `t2`.`t1_id` = `t1`.`id` join `t3` on `t3`.`t2_id` = `t2`.`id`
// 第一个参数可以用object
qb.join({ source: 't1', target: 't2', mapping: { t1_id: id } }) => // join `t2` on `t2`.`t1_id` = `t1`.`id`
where参数类型 type name = string type cb = (qb: queryBuilder) => queryBuilder | { sql: string, values: any[] } | void type value = string | number | boolean | cb | null | undefined type valueArr = value[] type ops = 'in' | 'not in' | 'like' | 'not like' | 'is' | 'is not' | '!=' | '>' | '<' | '>=' | '<=' | '=' | '<>' | '<=>' type opVal = { operator: ops, value: value, prefix?: boolean, suffix?: boolean } type opsInObj = 'in' | 'not in' | 'like' | 'not like' | '%like' | 'not %like' | 'like%' | 'not like%' | 'is' | 'is not' | '!=' | '>' | '<' | '>=' | '<=' | '=' | '<>' | '<=>' type opObj = { [key: opsInObj]: val } type conditionObj = { [key: name]: value | valueArr | opVal | opObj } type conditionObjWithOr = { [anyKey: string]: conditionObj[] } type withTable = { [table: name]: conditionObje | conditionObjWithOr } type conditionArr = (conditionObj | conditionObjWithOr | withTable)[]函数列表说明where(condition: conditionObj, tableName?: name) => qb最外层使用and连接，且只有and连接where(condition: conditionObjWithOr, tableName?: name) => qb最外层使用and连接，中间含or，and子句where(condition: withTable) => qb多个表联合过滤where(condition: conditionArr, tableName?: name) => qb最层使用or连接，中间含and，or子句例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到/** ******************** 只用and连接 *************************************/
// value 是简单类型
qb.where({ a: 1, b: 'b', c: true })
// => where `a` = 1 and `b` = 'b' and `c` = true
// value是简单类型的数组，转成使用in函数，使用第二参数，指定table名字
qb.where({ a: [1, 2 ,3], b: 'str' }, 't')
// => where `t`.`a` in (1, 2, 3) and `t`.`b` = `str`
// value使用sub函数
qb.where({ a: sub => sub.select('f1').from('t').where({ f2: 1 }), b: 2 })
// => where `a` = (select `f1` from `t` where `f2` = 1) and b = 2
// value使用 {operator, value}对象
qb.where({ a: { operator: '>', value: 1 }, b: { operator: 'like', value: 'str', prefix: true } })
// => where `a` > 1 and `b` like '%str'
// value使用 {operator, value}对象，且对象的value是sub函数
qb.where({ a: { operator: 'in', value: sub => sub.select('f1').from('t').where({ f2: 1 }) }, b: 1 })
// => where `a` in (select `f1` from `t` where `f2` = 1) and b = 1
// value使用 限制key是固定operator取值 的对象
qb.where({ a: { in: [1, 2, 3] }, b: { '>': 1, '<': 10 } })
// => where `a` in (1, 2, 3) and `b` > 1 and `b` < 10'
// value使用 限制key是固定operator取值 的对象，且对象value是sub函数
qb.where({ a: { in: sub => sub.select('f1').from('t').where({ f2: 1 }) }, b: 1 })
// => where `a` in (select `f1` from `t` where `f2` = 1) and b = 1
/** ************** 对or条件使用and连接，即通过()提升or的优先级 ************************/
// 当参数对象的value类型时对象数组时，数组内的对象使用or连接，且通过()提升优先级，数组内对象如果含多个key时依旧使用and连接
// 此时参数对象的key无意义，只要不重复即可，因为对象key重复会出现覆盖。
qb.where({
a: { is: undefined },
or1: [
{ b: { '<': 2, '>': 0 } },
{ b: [1, 2] },
],
or2: [
{ c: 1 },
{ d: { 'like%': str } },
{ e: '3', f: true, or: [{ g: { is: null } }, { g: { like: 'gg' } }] },
],
h: 'str',
}, 't')
// 为了方便阅读，添加了本不存在的空格和缩进
// => where `t`.`a` is NULL
// and ((`t`.`b` < 2 and `t`.`b` > 0) or `t`.`b` in (1, 2))
// and (`t`.`c` = 1
// or `t`.`d` like 'str%'
// or (`t`.`e` = '3' and `t`.`f` = true and (`t`.`g` is NULL or `t`.`g` like '%gg%'))
// )
// and `t`.`h` = 'str'
/** **************** 多个表联合查询，对多个表字段同时过滤 *************************/
// 表名作为参数对象的key，对象的value是条件表达式，与前面函数的第一个参数使用相同的schema
// 可以认为是在原来的基础上添加包裹了一级tableName而成，
// 但是tableName的值(也就是参数对象的key)不能是operator，value, 以及operator的取值（比如in，is）
// 因为，一旦key取为这些值会回退为操作符的场景，不再会当做tableName
// 第二个参数不用传，传了也无效果
qb.where({ t1: { a: { '=': 1 } }, t2: { b: { like: 'a' } } }, 't')
// => where `t1`.`a` = 1 and `t2`.`b` like '%a%'
qb.where({
t1: { a: { is: undefined } },
or1: [
{ t1: { b: { '<': 2, '>': 0 } } },
{ t2: { b: [1, 2] } },
],
or2: [
{ t3: { c: 1 } },
{ t3: { d: { '<': 10 } } },
{
t3: { e: '3' },
t4: { f: true },
or: [
{ t4: { g: { is: null } } },
{ t4: { g: { like: 'gg' } } },
],
},
],
t5: { h: 'str' },
})
// 为了方便阅读，添加了本不存在的空格和缩进
// => where `t1`.`a` is NULL
// and ((`t1`.`b` < 2 and `t1`.`b` > 0) or `t2`.`b` in (1, 2))
// and (`t3`.`c` = 1
// or `t3`.`d` < 10
// or (`t3`.`e` = '3' and `t4`.`f` = true and (`t4`.`g` is NULL or `t4`.`g` like '%gg%'))
// )
// and `t5`.`h` = 'str
/** **************** 最外层使用or连接语句 ***********************/
// 但参数不再是对象，而是对象数组时，则各个对象生成的语句使用or连接， 对象内的连接规则同前面的函数
// 不带tableName
qb.where([{ a: { '>': 0, '<': 10 } }, { a: 15 }])
// => where (`a` > 0 and `a` < 10) or `a` = 15'
// 带单个tableName
qb.where([{ a: { '>': 0, '<': 10 } }, { a: 15 }], 't')
// => where (`t`.`a` > 0 and `t`.`a` < 10) or `t`.`a` = 15'
// 多个tableName, 第二个参数不用传，传了也无效
qb.where([
{ t1: { a: { '>': 0, '<': 10 } } },
{ t1: { a: 15 } },
{
t2: { c: { is: undefined } },
or1: [
{ t3: { b: { '<': 2, '>': 0 } } },
{ t3: { b: [1, 2] } },
],
or2: [
{ t4: { d: 20 } },
{ t5: { d: { '<': 10 } } },
{
t6: { e: '3' },
t7: { f: true },
or: [
{ t7: { g: { is: null } } },
{ t8: { g: { like: 'gg' } } },
],
},
],
t9: { h: 'str' },
},
])
// 为了方便阅读，添加了本不存在的空格和缩进
// => where (`t1`.`a` > 0 and `t1`.`a` < 10)
// or `t1`.`a` = 15
// or (`t2`.`c` is NULL
// and ((`t3`.`b` < 2 and `t3`.`b` > 0) or `t3`.`b` in (1, 2))
// and (`t4`.`d` = 20
// or `t5`.`d` < 10
// or (`t6`.`e` = '3'
// and `t7`.`f` = true
// and (`t7`.`g` is NULL or `t8`.`g` like '%gg%')
// )
// )
// and `t9`.`h` = 'str'
// )
order by参数类型 type field = string type order = 'desc' | 'asc' | 'DESC' | 'ASC' type fieldOrder = string type fieldsOrder = { [key: field]: order }函数 列表说明order(param: fieldOrder) => qb对一个字段排序，排序方式与字段间使用空格连接，可以没有排序方式order(param: fieldsOrder) => qb对多个字段排序，key是字段，value是排序方式，value是空值表示不填排序方式例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 对一个字段排序
qb.order('a') // => order by `a`
qb.order('a desc') // => order by `a` desc
// 对多个字段排序
qb.order({ a: '', b: 'desc' }) // => order by `a`, `b` desc
qb.order({ a: 'DESC', b: 'ASC' }) // => order by `a` DESC, `b` ASC
page limit offset参数类型 type val = number函数列表说明limit(size: val) => qbsize需大于0offset(size: val) => qbsize需大于0page(size: val, page?: val) => qbpage是对limit和offse的组合例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到qb.limit(1) // => limit 1
qb.offset(1) // => offset 1
qb.page(10) // => limit 10
qb.page(10, 1) // => limit 10
qb.page(10, 2) // => limit 10 offset 10
group by参数类型 type name = string type table = { [key: name]: name | name[] } 函数列表说明group(field: name, tableName?: name) => qb对单个字段聚合group(fields: name[], tableName?: string) => qb对多个字段聚合group(fields: table) => qb对多个表的字段聚合例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 单个字段聚合
qb.group('a') // => group by `a`
qb.group('a', 't') // => group by `t`.`a`
// 多个字段聚合
qb.group(['a', 'b']) // => group by `a` `b`
qb.group(['a', 'b'], 't') // => group by `t`.`a` `t`.`b`
// 多个表的字段聚合
qb.group({ t: 'a' }) // => group by `t`.`a`
qb.group({ t1: ['a', 'b'], t2: 'c' }) // => group by `t1`.`a` `t1`.`b` `t2`.`c`
insert参数类型 type name = string type data = { [key: string]: string | number | boolean | null | undefined }函数 列表说明insert(tableName: name, data: data) => qb插入单行数据insert(tableName: name, data: data[]) => qb插入多行数据例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 插入单行数据，使用set语句
qb.insert('t', { a: 1, b: '2', c: true }) // => insert into `t` set `a` = 1, `b` = '2', `c` = true
// 插入多行数据，使用values语句
qb.insert('t', [{ a: 1, b: 'b' }, { a: 2, b: 'b' }]) // => insert into `t` (`a`, `b`) values (1, 'b'), (2, 'b')
update参数类型 type name = string type data = { [key: string]: string | number | boolean | null | undefined } type where = Array | Object // 参考where部分函数列表说明update(tableName: name, data: data, where?: where) => qb第三个where参数选填，与where函数参数类型相同例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到qb.update('t', { a: true, b: 'str', c: null， d: 1 })
// => update `t` set `a` = true, `b` = 'str', `c` = NULL, `d` = 1
qb.update('t', { a: true, b: 'str', c: null }, [{ id: 1 }, { f: 2 }])
// => update `t` set `a` = true, `b` = 'str', `c` = NULL where `id` = 1 or `f` = 2
delete参数类型 type name = string type where = Array | Object // 参考where部分函数列表说明delete(tableName: name, where?: where) => qb第二个where参数选填，与where函数参数类型相同例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 单个字段，如果是字符串则认为是字段，数字或布尔则认为是值
qb.delete('t') // => delete from `t`
qb.delete('t', { id: 1 }) // => delete from `t` where `id` = 1'
sub padEnd当内置函数不能满足需求时，可通过sub高阶函数自定义sql，sub只接受一个回调函数类型的参数, 该回调函数有一个参数qb。qb是一个全新的queryBuilder对象，当回调函数使用非箭头函数时，this指向这个queryBuilder对象，因此使用this与使用qb是等效的回调函数的返回值可有可无，如果有返回值，返回值必须是包含 { sql: string, values: [] } 的对象，qb-mysql 内部会使用sql和values的值用于生成query对象，如果没有返回值，则会直接使用回调函数参数queryBuilder对象中的值。padEnd是辅助型函数，用于向queryBuilder.sql和queryBuilder.value上追加内容，一般会配合sub函数一起使用。参数类型 type cb = (qb: queryBuilder) => queryBuilder | { sql: string, values: any[] } | void type values = any[] type val = string | values函数 列表说明sub(callback: cb) => qbcb函数参数是一个新的queryBuilder对象，返回值可有可无padEnd(str: val, values?: values) => qb向queryBuilder.sql追加string，第2个参数向queryBuilder.values追加值例子以下的结果均通过调用 console.log(mysql.format(...qb.toQuery())) 得到// 使用子查询
qb.select('f1')
.from('t1')
.padEnd(' where ?? in (', ['f2'])
.sub((builder) => builder.select('f3').from('t2')
.padEnd(')')
// => 'select `f1` from `t1` where `f2` in (select `f3` from `t2`)
clearqb-mysql 支持了多query查询，当使用多个语句（即多次调用select, insert, update, delete）时，会自动在各条语句间插入分号（;）clear用于清空queryBuilder中已经构建的query语句，当需要新建一条query时，可以使用 const queryBuilder = new QueryBuilder()的方式，也可以在已经实例化的queryBuilder对象上调用queryBuilder.clear()参数类型 无函数列表说明clear() => qb一般用于同一作用域中多次调用函数生成query时，清除前面生成的内容例子 // 1. 创建实例
const qb = new QueryBuilder()
qb.select('a').from('t').select(qb => qb.count()).form('t')
// => selectafromt;select count(*) fromt`
// 2. 如果调用clear， 在同一个作用域中继续执行以下语句
qb.clear().select(qb => qb.count()).form('t')
// => select count(*) from t
// 2. 如果不调用clear，在同一个作用域中继续执行以下语句
qb.select(qb => qb.count()).form('t')
// => select a from t;select count() from t;select count() from t
注意事项 调用各个子函数时，调用顺序要严格按照 sql 语句的语法，为了最小化代码体积，qb-mysql并未做语法分析和检测，因此及时语句有错误也会生成query对象。比如 qb.from('t').select('a') 会生成 from `t`select `a`尤其要特别注意 order, limit, offset 的顺序，写反了会导致sql查询异常 qb-mysql支持了多query查询，当使用多个语句时，会自动在各个语句间插入分号（;），但要注意这不是事务安全的，例如 // 同时查询表长度
qb.select('a').from('t').select(qb => qb.count()).form('t')
// => selectafromt;select count(*) fromt`
// 更新数据的同时查询数据，注意这并不是事务安全的，因引擎不同，可能会查到更新前的数据
qb.update('t', { a: 'a' }, { id: 1 } ).select().form('t').where({ id: 1 })
// => update t set a = 'a' where id = 1;select * from t where id = 1 ```
发布于 2021-03-09 23:12SQL 语句Node.js前端开发赞同1 条评论分享喜欢收藏申请转载文章被以下专栏收录巨人的肩膀我们如此渺小，只是站在了巨人