AI 助理
备案控制台
开发者社区 数据库 文章 正文

用建造者模式实现一个防SQL注入的ORM框架

2023-08-30 84
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 以构建一门课程为例，一个完整的课程由PPT课件、回放视频、课堂笔记、课后作业组成，但是这些内容的设置顺序可以随意调整，我们用建造者模式来代入理解一下。首先创建一个产品类Course。

本文节选自《设计模式就该这样学》

1 建造者模式的链式写法

以构建一门课程为例，一个完整的课程由PPT课件、回放视频、课堂笔记、课后作业组成，但是这些内容的设置顺序可以随意调整，我们用建造者模式来代入理解一下。首先创建一个产品类Course。

@Data
public class Course {
    private String name;
    private String ppt;
    private String video;
    private String note;
    private String homework;
    @Override
    public String toString() {
        return "CourseBuilder{" +
                "name='" + name + '\'' +
                ", ppt='" + ppt + '\'' +
                ", video='" + video + '\'' +
                ", note='" + note + '\'' +
                ", homework='" + homework + '\'' +
                '}';
    }
}

然后创建建造者类CourseBuilder，将复杂的创建过程封装起来，创建步骤由用户决定。

public class CourseBuilder {
    private Course course = new Course();
    public CourseBuilder addName(String name){
        course.setName(name);
        return this;
    }
    public CourseBuilder addPpt(String ppt){
        course.setPpt(ppt);
        return this;
    }
    public CourseBuilder addVideo(String video){
        course.setVideo(video);
        return this;
    }
    public CourseBuilder addNote(String note){
        course.setNote(note);
        return this;
    }
    public CourseBuilder addHomework(String homework){
        course.setHomework(homework);
        return this;
    }
    public Course builder(){
        return course;
    }
}

最后编写客户端测试代码。

    public static void main(String[] args) {
        CourseBuilder builder = new CourseBuilder()
                    .addName("设计模式")
                    .addPPT("【PPT课件】")
                    .addVideo("【回放视频】")
                    .addNote("【课堂笔记】")
                    .addHomework("【课后作业】");
        System.out.println(builder.build());
}

这样的写法是不是很眼熟？后面分析建造者模式在框架源码中的应用时大家就会明白。再来看一下类图的变化，如下图所示。

20211028161258399.png

2 使用静态内部类实现建造者模式

事实上，在平常的编码中，我们通常都会忽略对象的复杂性，优先考虑使用工厂模式创建对象，而不是建造者模式。因为工厂模式和建造者模式的作用都是创建一个产品对象，而工厂模式的结构更加简洁直接（没有Builder和 Director），因此更常使用。

一般情况下，我们更习惯使用静态内部类的方式实现建造者模式，即一个产品类内部自动带有一个具体建造者，由它负责该产品的组装创建，不再需要Builder和Director，这样，产品表示与创建之间的联系更加紧密，结构更加紧凑，同时使得建造者模式的形式更加简洁。

如果采用静态内部类形式实现建造者模式，则前面的案例可以改写如下。

@Data
public class Course {
    private String name;
    private String ppt;
    private String video;
    private String note;
    private String homework;
    @Override
    public String toString() {
        return "Course{" +
                "name='" + name + '\'' +
                ", ppt='" + ppt + '\'' +
                ", video='" + video + '\'' +
                ", note='" + note + '\'' +
                ", homework='" + homework + '\'' +
                '}';
    }
    public static class Builder {
        private Course course = new Course();
        public Builder addName(String name){
            course.setName(name);
            return this;
        }
        public Builder addPpt(String ppt){
            course.setPpt(ppt);
            return this;
        }
        public Builder addVideo(String video){
            course.setVideo(video);
            return this;
        }
        public Builder addNote(String note){
            course.setNote(note);
            return this;
        }
        public Builder addHomework(String homework){
            course.setHomework(homework);
            return this;
        }
        public Course builder(){
            return course;
        }
    }
}

客户端测试代码如下。

    public static void main(String[] args) {
         Course course = new Course.Builder()
                .addName("设计模式")
                .addPpt("【PPT课件】")
                .addVideo("【录播视频】")
                 .builder();
        System.out.println(course);
    }

这样，代码也会看上去更加简洁，不会让人感觉到多了一个类。

3 使用建造者模式动态构建SQL语句

下面来看一个实战案例，这个案例参考了开源框架JPA的SQL构造模式。我们在构造SQL查询条件的时候，需要根据不同的条件来拼接SQL字符串。如果查询条件复杂，则SQL拼接的过程也会变得非常复杂，从而给代码维护带来非常大的困难。因此，我们用建造者类QueryRuleSqlBuilder将复杂的SQL构造过程进行封装，用QueryRule对象专门保存SQL查询时的条件，最后根据查询条件，自动生成SQL语句。首先创建QueryRule类，代码如下。

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
 * QueryRule，主要功能用于构造查询条件
 * 
 * @author Tom
 */
public final class QueryRule implements Serializable
{
  private static final long serialVersionUID = 1L;
  public static final int ASC_ORDER = 101;
  public static final int DESC_ORDER = 102;
  public static final int LIKE = 1;
  public static final int IN = 2;
  public static final int NOTIN = 3;
  public static final int BETWEEN = 4;
  public static final int EQ = 5;
  public static final int NOTEQ = 6;
  public static final int GT = 7;
  public static final int GE = 8;
  public static final int LT = 9;
  public static final int LE = 10;
  public static final int ISNULL = 11;
  public static final int ISNOTNULL = 12;
  public static final int ISEMPTY = 13;
  public static final int ISNOTEMPTY = 14;
  public static final int AND = 201;
  public static final int OR = 202;
  private List<Rule> ruleList = new ArrayList<Rule>();
  private List<QueryRule> queryRuleList = new ArrayList<QueryRule>();
  private String propertyName;
  private QueryRule() {}
  private QueryRule(String propertyName) {
    this.propertyName = propertyName;
  }
  public static QueryRule getInstance() {
    return new QueryRule();
  }
  /**
   * 添加升序规则
   * @param propertyName
   * @return
   */
  public QueryRule addAscOrder(String propertyName) {
    this.ruleList.add(new Rule(ASC_ORDER, propertyName));
    return this;
  }
  /**
   * 添加降序规则
   * @param propertyName
   * @return
   */
  public QueryRule addDescOrder(String propertyName) {
    this.ruleList.add(new Rule(DESC_ORDER, propertyName));
    return this;
  }
  public QueryRule andIsNull(String propertyName) {
    this.ruleList.add(new Rule(ISNULL, propertyName).setAndOr(AND));
    return this;
  }
  public QueryRule andIsNotNull(String propertyName) {
    this.ruleList.add(new Rule(ISNOTNULL, propertyName).setAndOr(AND));
    return this;
  }
  public QueryRule andIsEmpty(String propertyName) {
    this.ruleList.add(new Rule(ISEMPTY, propertyName).setAndOr(AND));
    return this;
  }
  public QueryRule andIsNotEmpty(String propertyName) {
    this.ruleList.add(new Rule(ISNOTEMPTY, propertyName).setAndOr(AND));
    return this;
  }
  public QueryRule andLike(String propertyName, Object value) {
    this.ruleList.add(new Rule(LIKE, propertyName, new Object[] { value }).setAndOr(AND));
    return this;
  }
  public QueryRule andEqual(String propertyName, Object value) {
    this.ruleList.add(new Rule(EQ, propertyName, new Object[] { value }).setAndOr(AND));
    return this;
  }
  public QueryRule andBetween(String propertyName, Object... values) {
    this.ruleList.add(new Rule(BETWEEN, propertyName, values).setAndOr(AND));
    return this;
  }
  public QueryRule andIn(String propertyName, List<Object> values) {
    this.ruleList.add(new Rule(IN, propertyName, new Object[] { values }).setAndOr(AND));
    return this;
  }
  public QueryRule andIn(String propertyName, Object... values) {
    this.ruleList.add(new Rule(IN, propertyName, values).setAndOr(AND));
    return this;
  }
  public QueryRule andNotIn(String propertyName, List<Object> values) {
    this.ruleList.add(new Rule(NOTIN, 
                  propertyName, 
                  new Object[] { values }).setAndOr(AND));
    return this;
  }
  //此处省略部分代码
  public List<Rule> getRuleList() {
    return this.ruleList;
  }
  public List<QueryRule> getQueryRuleList() {
    return this.queryRuleList;
  }
  public String getPropertyName() {
    return this.propertyName;
  }
  protected class Rule implements Serializable {
    private static final long serialVersionUID = 1L;
    private int type; //规则的类型
    private String property_name;
    private Object[] values;
    private int andOr = AND;
    public Rule(int paramInt, String paramString) {
      this.property_name = paramString;
      this.type = paramInt;
    }
    public Rule(int paramInt, String paramString,
        Object[] paramArrayOfObject) {
      this.property_name = paramString;
      this.values = paramArrayOfObject;
      this.type = paramInt;
    }
    public Rule setAndOr(int andOr){
      this.andOr = andOr;
      return this;
    }
    public int getAndOr(){
      return this.andOr;
    }
    public Object[] getValues() {
      return this.values;
    }
    public int getType() {
      return this.type;
    }
    public String getPropertyName() {
      return this.property_name;
    }
  }
}

然后创建QueryRuleSqlBuilder类。

package com.tom.vip.pattern.builder.sql;
/**
 * 根据QueryRule自动构建SQL语句
 * @author Tom
 *
 */
public class QueryRuleSqlBuilder {
  private int CURR_INDEX = 0; //记录参数所在的位置
  private List<String> properties; //保存列名列表
  private List<Object> values; //保存参数值列表
  private List<Order> orders; //保存排序规则列表
  private String whereSql = ""; 
  private String orderSql = "";
  private Object [] valueArr = new Object[]{};
  private Map<Object,Object> valueMap = new HashMap<Object,Object>();
  /**
   * 获得查询条件
   * @return
   */
  private String getWhereSql(){
    return this.whereSql;
  }
  /**
   * 获得排序条件
   * @return
   */
  private String getOrderSql(){
    return this.orderSql;
  }
  /**
   * 获得参数值列表
   * @return
   */
  public Object [] getValues(){
    return this.valueArr;
  }
  /**
   * 获得参数列表
   * @return
   */
  private Map<Object,Object> getValueMap(){
    return this.valueMap;
  }
  /**
   * 创建SQL构造器
   * @param queryRule
   */
  public QueryRuleSqlBuilder(QueryRule queryRule) {
    CURR_INDEX = 0;
    properties = new ArrayList<String>();
    values = new ArrayList<Object>();
    orders = new ArrayList<Order>();
    for (QueryRule.Rule rule : queryRule.getRuleList()) {
      switch (rule.getType()) {
      case QueryRule.BETWEEN:
        processBetween(rule);
        break;
      case QueryRule.EQ:
        processEqual(rule);
        break;
      case QueryRule.LIKE:
        processLike(rule);
        break;
      case QueryRule.NOTEQ:
        processNotEqual(rule);
        break;
      case QueryRule.GT:
        processGreaterThen(rule);
        break;
      case QueryRule.GE:
        processGreaterEqual(rule);
        break;
      case QueryRule.LT:
        processLessThen(rule);
        break;
      case QueryRule.LE:
        processLessEqual(rule);
        break;
      case QueryRule.IN:
        processIN(rule);
        break;
      case QueryRule.NOTIN:
        processNotIN(rule);
        break;
      case QueryRule.ISNULL:
        processIsNull(rule);
        break;
      case QueryRule.ISNOTNULL:
        processIsNotNull(rule);
        break;
      case QueryRule.ISEMPTY:
        processIsEmpty(rule);
        break;
      case QueryRule.ISNOTEMPTY:
        processIsNotEmpty(rule);
        break;
      case QueryRule.ASC_ORDER:
        processOrder(rule);
        break;
      case QueryRule.DESC_ORDER:
        processOrder(rule);
        break;
      default:
        throw new IllegalArgumentException("type"+rule.getType()+"not supported.");
      }
    }
    //拼装where语句
    appendWhereSql();
    //拼装排序语句
    appendOrderSql();
    //拼装参数值
    appendValues();
  }
  /**
   * 去掉order
   * 
   * @param sql
   * @return
   */
  private String removeOrders(String sql) {
    Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
    Matcher m = p.matcher(sql);
    StringBuffer sb = new StringBuffer();
    while (m.find()) {
      m.appendReplacement(sb, "");
    }
    m.appendTail(sb);
    return sb.toString();
  }
  /**
   * 去掉select
   * 
   * @param sql
   * @return
   */
  private String removeSelect(String sql) {
    if(sql.toLowerCase().matches("from\\s+")){
      int beginPos = sql.toLowerCase().indexOf("from");
      return sql.substring(beginPos);
    }else{
      return sql;
    }
  }
  /**
   * 处理like
   * @param rule
   */
  private  void processLike(QueryRule.Rule rule) {
    if (ArrayUtils.isEmpty(rule.getValues())) {
      return;
    }
    Object obj = rule.getValues()[0];
    if (obj != null) {
      String value = obj.toString();
      if (!StringUtils.isEmpty(value)) {
        value = value.replace('*', '%');
        obj = value;
      }
    }
    add(rule.getAndOr(),rule.getPropertyName(),"like","%"+rule.getValues()[0]+"%");
  }
  /**
   * 处理between
   * @param rule
   */
  private  void processBetween(QueryRule.Rule rule) {
    if ((ArrayUtils.isEmpty(rule.getValues()))
        || (rule.getValues().length < 2)) {
      return;
    }
    add(rule.getAndOr(),rule.getPropertyName(),"","between",rule.getValues()[0],"and");
    add(0,"","","",rule.getValues()[1],"");
  }
//此处省略部分代码
  /**
   * 加入SQL查询规则队列
   * @param andOr and或者or
   * @param key 列名
   * @param split 列名与值之间的间隔
   * @param value 值
   */
  private  void add(int andOr,String key,String split ,Object value){
    add(andOr,key,split,"",value,"");
  }
  /**
   * 加入SQL查询规则队列
   * @param andOr and或者or
   * @param key 列名
   * @param split 列名与值之间的间隔
   * @param prefix 值前缀
   * @param value 值
   * @param suffix 值后缀
   */
  private  void add(int andOr,String key,String split ,String prefix,Object value,String    suffix){
    String andOrStr = (0 == andOr ? "" :(QueryRule.AND == andOr ? " and " : " or "));  
    properties.add(CURR_INDEX, 
     andOrStr + key + " " + split + prefix + (null != value ? " ? " : " ") + suffix);
    if(null != value){
      values.add(CURR_INDEX,value);
      CURR_INDEX ++;
    }
  }
  /**
   * 拼装where语句
   */
  private void appendWhereSql(){
    StringBuffer whereSql = new StringBuffer();
    for (String p : properties) {
      whereSql.append(p);
    }
    this.whereSql = removeSelect(removeOrders(whereSql.toString()));
  }
  /**
   * 拼装排序语句
   */
  private void appendOrderSql(){
    StringBuffer orderSql = new StringBuffer();
    for (int i = 0 ; i < orders.size(); i ++) {
      if(i > 0 && i < orders.size()){
        orderSql.append(",");
      }
      orderSql.append(orders.get(i).toString());
    }
    this.orderSql = removeSelect(removeOrders(orderSql.toString()));
  }
  /**
   * 拼装参数值
   */
  private void appendValues(){
    Object [] val = new Object[values.size()];
    for (int i = 0; i < values.size(); i ++) {
      val[i] = values.get(i);
      valueMap.put(i, values.get(i));
    }
    this.valueArr = val;
  }
  public String builder(String tableName){
    String ws = removeFirstAnd(this.getWhereSql());
    String whereSql = ("".equals(ws) ? ws : (" where " + ws));
    String sql = "select * from " + tableName + whereSql;
    Object [] values = this.getValues();
    String orderSql = this.getOrderSql();
    orderSql = (StringUtils.isEmpty(orderSql) ? " " : (" order by " + orderSql));
    sql += orderSql;
    return sql;
  }
  private String removeFirstAnd(String sql){
    if(StringUtils.isEmpty(sql)){return sql;}
    return sql.trim().toLowerCase().replaceAll("^\\s*and", "") + " ";
  }
}

接着创建Order类。

/**
 * SQL排序组件
 * @author Tom
 */
public class Order {
  private boolean ascending; //升序还是降序
  private String propertyName; //哪个字段升序，哪个字段降序
  public String toString() {
    return propertyName + ' ' + (ascending ? "asc" : "desc");
  }
  /**
   * Constructor for Order.
   */
  protected Order(String propertyName, boolean ascending) {
    this.propertyName = propertyName;
    this.ascending = ascending;
  }
  /**
   * Ascending order
   *
   * @param propertyName
   * @return Order
   */
  public static Order asc(String propertyName) {
    return new Order(propertyName, true);
  }
  /**
   * Descending order
   *
   * @param propertyName
   * @return Order
   */
  public static Order desc(String propertyName) {
    return new Order(propertyName, false);
  }
}

最后编写客户端测试代码。

public static void main(String[] args) {
        QueryRule queryRule = QueryRule.getInstance();
        queryRule.addAscOrder("age");
        queryRule.andEqual("addr","Changsha");
        queryRule.andLike("name","Tom");
        QueryRuleSqlBuilder builder = new QueryRuleSqlBuilder(queryRule);
        System.out.println(builder.builder("t_member"));
        System.out.println("Params: " + Arrays.toString(builder.getValues()));
}

这样一来，客户端代码就非常清楚，运行结果如下图所示。

20211028161258619.png


【推荐】Tom弹架构：30个设计模式真实案例（附源码），挑战年薪60W不是梦


本文为“Tom弹架构”原创，转载请注明出处。技术在于分享，我分享我快乐！

如果本文对您有帮助，欢迎关注和点赞；如果您有任何建议也可留言评论或私信，您的支持是我坚持创作的动力。

文章标签：
SQL
设计模式
Java
关键词：
SQL框架
SQL注入
SQL orm
Tom弹架构
目录
相关文章
汀丶人工智能
|
1月前
|
SQL 数据采集 自然语言处理
NL2SQL之DB-GPT-Hub<详解篇>:text2sql任务的微调框架和基准对比
NL2SQL之DB-GPT-Hub<详解篇>:text2sql任务的微调框架和基准对比
汀丶人工智能
68 2
番茄酱脑袋
|
3月前
|
SQL Java 数据库
建模底层逻辑问题之ORM框架建模中，执行SQL的过程中被抽象和组织是如何实现的
建模底层逻辑问题之ORM框架建模中，执行SQL的过程中被抽象和组织是如何实现的
番茄酱脑袋
37 2
东方睿赢
|
2月前
|
SQL 安全 数据库
惊！Python Web安全黑洞大曝光：SQL注入、XSS、CSRF，你中招了吗？
在数字化时代，Web应用的安全性至关重要。许多Python开发者在追求功能时，常忽视SQL注入、XSS和CSRF等安全威胁。本文将深入剖析这些风险并提供最佳实践：使用参数化查询预防SQL注入；通过HTML转义阻止XSS攻击；在表单中加入CSRF令牌增强安全性。遵循这些方法，可有效提升Web应用的安全防护水平，保护用户数据与隐私。安全需持续关注与改进，每个细节都至关重要。
东方睿赢
129 5
众所周知
|
2月前
|
SQL 安全 数据库
深度揭秘：Python Web安全攻防战，SQL注入、XSS、CSRF一网打尽！
在Web开发领域，Python虽强大灵活，却也面临着SQL注入、XSS与CSRF等安全威胁。本文将剖析这些常见攻击手段，并提供示例代码，展示如何利用参数化查询、HTML转义及CSRF令牌等技术构建坚固防线，确保Python Web应用的安全性。安全之路永无止境，唯有不断改进方能应对挑战。
众所周知
67 5
众所周知
|
2月前
|
SQL 安全 数据安全/隐私保护
Python Web安全大挑战：面对SQL注入、XSS、CSRF，你准备好了吗？
在构建Python Web应用时，安全性至关重要。本文通过三个真实案例，探讨了如何防范SQL注入、XSS和CSRF攻击。首先，通过参数化查询替代字符串拼接，防止SQL注入；其次，利用HTML转义机制，避免XSS攻击；最后，采用CSRF令牌验证，保护用户免受CSRF攻击。这些策略能显著增强应用的安全性，帮助开发者应对复杂的网络威胁。安全是一个持续的过程，需不断学习新知识以抵御不断变化的威胁。
众所周知
117 1
东方睿赢
|
2月前
|
SQL 安全 数据库
Python Web开发者必看！SQL注入、XSS、CSRF全面解析，守护你的网站安全！
在Python Web开发中，构建安全应用至关重要。本文通过问答形式，详细解析了三种常见Web安全威胁——SQL注入、XSS和CSRF，并提供了实用的防御策略及示例代码。针对SQL注入，建议使用参数化查询；对于XSS，需对输出进行HTML编码；而防范CSRF，则应利用CSRF令牌。通过这些措施，帮助开发者有效提升应用安全性，确保网站稳定运行。
东方睿赢
47 1
众所周知
|
2月前
|
SQL 安全 数据库
深度揭秘：Python Web安全攻防战，SQL注入、XSS、CSRF一网打尽！
在Web开发领域，Python虽强大灵活，但安全挑战不容小觑。本文剖析Python Web应用中的三大安全威胁：SQL注入、XSS及CSRF，并提供防御策略。通过示例代码展示如何利用参数化查询、HTML转义与CSRF令牌构建安全防线，助您打造更安全的应用。安全是一场持久战，需不断改进优化。
众所周知
46 3
龙大吉
|
2月前
|
SQL 安全 数据库
从入门到精通：Python Web安全守护指南，SQL注入、XSS、CSRF全防御！
【9月更文挑战第13天】在开发Python Web应用时，安全性至关重要。本文通过问答形式，详细介绍如何防范SQL注入、XSS及CSRF等常见威胁。通过使用参数化查询、HTML转义和CSRF令牌等技术，确保应用安全。附带示例代码，帮助读者从入门到精通Python Web安全。
龙大吉
87 6
龙大吉
|
2月前
|
SQL 安全 JavaScript
告别Web安全小白！Python实战指南：抵御SQL注入、XSS、CSRF的秘密武器！
【9月更文挑战第12天】在Web开发中，安全漏洞如同暗礁，尤其对初学者而言，SQL注入、跨站脚本（XSS）和跨站请求伪造（CSRF）是常见挑战。本文通过实战案例，展示如何利用Python应对这些威胁。首先，通过参数化查询防止SQL注入；其次，借助Jinja2模板引擎自动转义机制抵御XSS攻击；最后，使用Flask-WTF库生成和验证CSRF令牌，确保转账功能安全。掌握这些技巧，助你构建更安全的Web应用。
龙大吉
51 5
众所周知
|
4月前
|
SQL 安全 数据库
Python Web开发者必学：SQL注入、XSS、CSRF攻击与防御实战演练！
【7月更文挑战第26天】在 Python Web 开发中, 安全性至关重要。本文聚焦 SQL 注入、XSS 和 CSRF 这三大安全威胁，提供实战防御策略。SQL 注入可通过参数化查询和 ORM 框架来防范；XSS 则需 HTML 转义用户输入与实施 CSP；CSRF 防御依赖 CSRF 令牌和双重提交 Cookie。掌握这些技巧，能有效加固 Web 应用的安全防线。安全是持续的过程，需贯穿开发始终。
众所周知
90 1
Python Web开发者必学：SQL注入、XSS、CSRF攻击与防御实战演练！

热门文章

最新文章

  • 1
    Flink SQL 实战：双流 join 场景应用
  • 2
    SQL0286N. DB2表空间的pagesize问题
  • 3
    Sqlserver与access数据库sql语法十大差异
  • 4
    SQL Server 2008 存储结构之DCM、BCM
  • 5
    SQL Server 存储过程的运用
  • 6
    SQL之用户自定义函数
  • 7
    Sql Server之旅——第二站 理解万恶的表扫描
  • 8
    tempdb对SQL Server性能的影响 <转>
  • 9
    SQL中几个快速定位语句
  • 10
    B+树查询上下级(sql实现）
  • 1
    实时计算 Flink版产品使用合集之将数据写入Elasticsearch时，若Elasticsearch中的字段类型为date，对应的SQL类型应该是什么
    67
  • 2
    实时计算 Flink版产品使用合集之flink-connector-mysql-cdc 和 flink-sql-connector-mysql-cdc有什么区别
    364
  • 3
    实时计算 Flink版产品使用合集之如果产品是基于ak的，可以提交sql任务到ecs自建hadoop集群吗
    61
  • 4
    实时计算 Flink版产品使用合集之使用Flink CDC SQL MongoDB Connector时，可以采取什么措施来提升数据消费速率
    101
  • 5
    实时计算 Flink版产品使用合集之当 SQL Server 源数据库中的数据更新后，CDC 吐出的操作（op）是怎样的
    64
  • 6
    MYSQL根据查询结果删除sql 去除重复id 新增对比前一条与后一条数据 去重3种方法​ 窗口函数
    126
  • 7
    实时计算 Flink版产品使用合集之如何选用 Flink SQL 的方式进行开发
    66
  • 8
    Mybatis多表关联查询与动态SQL（下）
    131
  • 9
    spark执行sql的原理是什么
    124
  • 10
    Mybatis多表关联查询与动态SQL（上）
    193

    • 相关课程

    更多
  • 如何在 PolarDB-X 中优化慢 SQL
  • SQL完全自学手册
  • SQL Server on Linux入门教程
  • SQL入门与实践
  • 数据库及SQL/MySQL基础
  • SQL进阶及查询

    • 相关电子书

    更多
  • SQL Server 2017
  • GeoMesa on Spark SQL
  • 原生SQL on Hadoop引擎- Apache HAWQ 2.x最新技术解密malili

    • 相关实验场景

    更多
  • SQL的增删改查及函数应用
  • PolarDB MySQL自动SQL限流
  • 如何开通SQL Server的专属集群
  • 使用DAS实现数据库自动SQL优化
  • 使用DAS实现数据库自动SQL限流
  • 一小时快速掌握 SQL 语法
    • 下一篇
    阿里云OSS设置跨域访问