精华内容
下载资源
问答
  • 主要为大家详细介绍了python实现图片横向纵向拼接,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 今天到一个客户那里解决问题,客户说原先的打印机换过后,打印出来的凭证就成了第一张正常(横向),第二张不正常(纵向),经过检查后发现,原来的打印机是横向进纸,而现在的打印机是纵向进纸的。 现作总结如下: ...

    今天到一个客户那里解决问题,客户说原先的打印机换过后,打印出来的凭证就成了第一张正常(横向),第二张不正常(纵向),经过检查后发现,原来的打印机是横向进纸,而现在的打印机是纵向进纸的。
    现作总结如下:
    若进纸方向为“横向进纸”,则打印设置须为240140mm;
    若进纸方向为“纵向进纸”,则打印设置须为140
    240mm。

    展开全文
  • 2 纵向思维与横向思维 思考维度可以从多方面进行充实,其中最常见的是增加横向纵向两个维度,本文也着重讨论两个维度。总体而言横向扩展的是思考广度,纵向扩展的是思考深度,而应用在不同场景中细节又各有不同。...

    欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章,主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等,同时欢迎大家加我个人微信「java_front」一起交流学习

    1 多维度思维

    在知乎上看到了这个有意思的问题:一头牛重800公斤,一座桥承重700公斤,牛应该怎么过桥。初看题目我们不难得出两个方案:桥梁加固、等待牛体重降至700公斤。

    这两个方案显然是正确的,但是我们不能就此止步。因为这类问题考察的是思维方法论,直接给出答案反而不是最重要的,对于这个问题我们可以从合理性、结构化、可行性三个维度进行分析。


    1.1 合理性分析

    一头800公斤的牛要通过承重700公斤的桥,这个需求本身合理吗?我们可以从必要性、紧迫性、替代性这三个维度提出三个问题:

    第一个问题问必要性:牛为什么要过桥,到底什么事情非要过桥不可

    第二个问题问紧迫性:如果非要过桥,那么这个过桥的需求是否紧急

    第三个问题问替代性:有没有什么替代方案,是否可以坐船或者绕路走


    1.2 结构化分析

    如果经过讨论结果是牛非过桥不可,那么我们再思考牛怎么过桥的方案。这里可以使用结构化思维,将大问题拆分为小维度,尽量做到不遗漏和不重复。影响过桥的因素有这几个维度:桥的维度、牛的维度、资源维度、环境维度。

    桥的维度:加固桥使承重大于800公斤

    牛的维度:等待牛的体重小于700公斤

    资源维度:使用一台吊机把牛运过去

    环境维度:取消环境重力


    1.3 可行性分析

    我们从桥的维度、牛的维度、资源维度、环境维度给出了方案,那么选择哪个方案呢?这就需要我们进行可行性评估,因时因地在资源制约下选择当前最合适的方案。

    加固桥方案经济成本较高,等待牛的体重小于700公斤时间成本较高,取消环境重力技术难度较高,所以使用一台吊机把牛运过去这个方案目前看来最合适。


    1.4 多维度思考

    经过我们从合理性、结构化、可行性三个维度梳理之后,虽然答案没有什么新颖之处,但是思维过程很清晰,思考方法也可以应用在其它问题。之所以思维过程清晰,是因为我们没有一上来直接给出答案,而是从多个维度对为题进行了分析,所以增加维度可以使思考过程更清晰和有章可循。


    2 纵向思维与横向思维

    思考维度可以从多方面进行充实,其中最常见的是增加横向和纵向两个维度,本文也着重讨论两个维度。总体而言横向扩展的是思考广度,纵向扩展的是思考深度,而应用在不同场景中细节又各有不同。


    2.1 时间管理四象限

    时间管理理论四象限法则从重要和紧急两个维度建立了一个四象限坐标,可以帮助我们解决主次不分的问题。当我们分配工作时间时,结合四象限法则,重要且紧急的任务优先级最高,而不要急于处理不重要且不紧急的任务。

    01 四象限法则.jpg


    2.2 金字塔原理

    金字塔思维的核心思想并不复杂:一件事情可以总结出一个中心思想,这个中心思想可以由三至七个论点支持,每个论点再可以由三至七个论据支持,基本结构图如下:

    金字塔原理内在结构可以从纵向和横向两个维度分析,纵向结构体现了结论先行和以上统下原则,横向结构体现了归类分组和逻辑递进原则。关于金字塔原理详细分析请参看我的文章金字塔思维怎么指导技术系统优化

    05 金字塔原理.jpg

    文章分析到这里,我们发现纵向和横向思维有助于厘清思路和增加条理性,下面我们来看看纵向和横向思维怎样帮助程序员处理复杂问题。


    3 架构设计如何应用纵横思维

    我们分析一个创建订单业务场景,当前有A、B、C三种订单类型,A类型订单价格9折,物流最大重量不能超过8公斤,不支持退款。B类型订单价格8折,物流最大重量不能超过5公斤,支持退款。C类型订单价格7折,物流最大重量不能超过1公斤,支持退款。按照需求字面含义平铺直叙地写代码也并不难实现:

    public class OrderServiceImpl implements OrderService {
    
        @Resource
        private OrderMapper orderMapper;
    
        @Override
        public void createOrder(OrderBO orderBO) {
            if (null == orderBO) {
                throw new RuntimeException("参数异常");
            }
            if (OrderTypeEnum.isNotValid(orderBO.getType())) {
                throw new RuntimeException("参数异常");
            }
            // A类型订单
            if (OrderTypeEnum.A_TYPE.getCode().equals(orderBO.getType())) {
                orderBO.setPrice(orderBO.getPrice() * 0.9);
                if (orderBO.getWeight() > 9) {
                    throw new RuntimeException("超过物流最大重量");
                }
                orderBO.setRefundSupport(Boolean.FALSE);
            }
            // B类型订单
            else if (OrderTypeEnum.B_TYPE.getCode().equals(orderBO.getType())) {
                orderBO.setPrice(orderBO.getPrice() * 0.8);
                if (orderBO.getWeight() > 8) {
                    throw new RuntimeException("超过物流最大重量");
                }
                orderBO.setRefundSupport(Boolean.TRUE);
            }
            // C类型订单
            else if (OrderTypeEnum.C_TYPE.getCode().equals(orderBO.getType())) {
                orderBO.setPrice(orderBO.getPrice() * 0.7);
                if (orderBO.getWeight() > 7) {
                    throw new RuntimeException("超过物流最大重量");
                }
                orderBO.setRefundSupport(Boolean.TRUE);
            }
            // 保存数据
            OrderDO orderDO = new OrderDO();
            BeanUtils.copyProperties(orderBO, orderDO);
            orderMapper.insert(orderDO);
        }
    }
    

    上述代码从功能上完全可以实现业务需求,但是程序员不仅要满足功能,还需要思考代码的可维护性。如果新增一种订单类型,或者新增一个订单属性处理逻辑,那么我们就要在上述逻辑中新增代码,如果处理不慎就会影响原有逻辑。为了避免牵一发而动全身这种情况,设计模式中的开闭原则要求我们面向新增开放,面向修改关闭,我认为这是设计模式中最重要的一条原则

    当需求变化时通过扩展而不是通过修改已有代码来实现变化,这样就保证代码稳定性。扩展也不是随意扩展,因为事先定义了算法,扩展也是根据算法扩展,用抽象构建框架,用实现扩展细节。标准意义的二十三种设计模式说到底最终都是在遵循开闭原则。

    那么如何改变平铺直叙的思考方式?这就要为问题分析加上纵向和横向两个维度,我选择使用分析矩阵方法,其中纵向表示策略,横向表示场景。

    06 分析矩阵.jpg

    3.1 纵向做隔离

    纵向维度表示策略,不同策略在逻辑上和业务上应该是隔离的,本实例包括优惠策略、物流策略和退款策略,策略作为抽象,不同的订单类型去扩展这个抽象。在设计模式中策略模式非常适合这种场景。

    3.1.1 优惠策略

    // 优惠策略
    public interface DiscountStrategy {
        public void discount(OrderBO orderBO);
    }
    
    // A类型订单优惠策略
    @Component
    public class TypeADiscountStrategy implements DiscountStrategy {
    
        @Override
        public void discount(OrderBO orderBO) {
            orderBO.setPrice(orderBO.getPrice() * 0.9);
        }
    }
    
    // A类型订单优惠策略
    @Component
    public class TypeBDiscountStrategy implements DiscountStrategy {
    
        @Override
        public void discount(OrderBO orderBO) {
            orderBO.setPrice(orderBO.getPrice() * 0.8);
        }
    }
    
    // A类型订单优惠策略
    @Component
    public class TypeCDiscountStrategy implements DiscountStrategy {
    
        @Override
        public void discount(OrderBO orderBO) {
            orderBO.setPrice(orderBO.getPrice() * 0.7);
        }
    }
    
    // 优惠策略工厂
    @Component
    public class DiscountStrategyFactory implements InitializingBean {
        private Map<String, DiscountStrategy> strategyMap = new HashMap<>();
    
        @Resource
        private TypeADiscountStrategy typeADiscountStrategy;
        @Resource
        private TypeBDiscountStrategy typeBDiscountStrategy;
        @Resource
        private TypeCDiscountStrategy typeCDiscountStrategy;
    
        public DiscountStrategy getStrategy(String type) {
            return strategyMap.get(type);
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            strategyMap.put(OrderTypeEnum.A_TYPE.getCode(), typeADiscountStrategy);
            strategyMap.put(OrderTypeEnum.B_TYPE.getCode(), typeBDiscountStrategy);
            strategyMap.put(OrderTypeEnum.C_TYPE.getCode(), typeCDiscountStrategy);
        }
    }
    
    // 优惠策略执行器
    @Component
    public class DiscountStrategyExecutor {
        private DiscountStrategyFactory discountStrategyFactory;
    
        public void discount(OrderBO orderBO) {
            DiscountStrategy discountStrategy = discountStrategyFactory.getStrategy(orderBO.getType());
            if (null == discountStrategy) {
                throw new RuntimeException("无优惠策略");
            }
            discountStrategy.discount(orderBO);
        }
    }
    

    3.1.2 物流策略

    // 物流策略
    public interface ExpressStrategy {
        public void weighing(OrderBO orderBO);
    }
    
    // A类型订单物流策略
    @Component
    public class TypeAExpressStrategy implements ExpressStrategy {
    
        @Override
        public void weighing(OrderBO orderBO) {
            if (orderBO.getWeight() > 9) {
                throw new RuntimeException("超过物流最大重量");
            }
        }
    }
    
    // B类型订单物流策略
    @Component
    public class TypeBExpressStrategy implements ExpressStrategy {
    
        @Override
        public void weighing(OrderBO orderBO) {
            if (orderBO.getWeight() > 8) {
                throw new RuntimeException("超过物流最大重量");
            }
        }
    }
    
    // C类型订单物流策略
    @Component
    public class TypeCExpressStrategy implements ExpressStrategy {
    
        @Override
        public void weighing(OrderBO orderBO) {
            if (orderBO.getWeight() > 7) {
                throw new RuntimeException("超过物流最大重量");
            }
        }
    }
    
    // 物流策略工厂
    @Component
    public class ExpressStrategyFactory implements InitializingBean {
        private Map<String, ExpressStrategy> strategyMap = new HashMap<>();
    
        @Resource
        private TypeAExpressStrategy typeAExpressStrategy;
        @Resource
        private TypeBExpressStrategy typeBExpressStrategy;
        @Resource
        private TypeCExpressStrategy typeCExpressStrategy;
    
        @Override
        public void afterPropertiesSet() throws Exception {
            strategyMap.put(OrderTypeEnum.A_TYPE.getCode(), typeAExpressStrategy);
            strategyMap.put(OrderTypeEnum.B_TYPE.getCode(), typeBExpressStrategy);
            strategyMap.put(OrderTypeEnum.C_TYPE.getCode(), typeCExpressStrategy);
        }
    
        public ExpressStrategy getStrategy(String type) {
            return strategyMap.get(type);
        }
    }
    
    // 物流策略执行器
    @Component
    public class ExpressStrategyExecutor {
        private ExpressStrategyFactory expressStrategyFactory;
    
        public void weighing(OrderBO orderBO) {
            ExpressStrategy expressStrategy = expressStrategyFactory.getStrategy(orderBO.getType());
            if (null == expressStrategy) {
                throw new RuntimeException("无物流策略");
            }
            expressStrategy.weighing(orderBO);
        }
    }
    

    3.1.3 退款策略

    // 退款策略
    public interface RefundStrategy {
        public void supportRefund(OrderBO orderBO);
    }
    
    // A类型订单退款策略
    @Component
    public class TypeARefundStrategy implements RefundStrategy {
    
        @Override
        public void supportRefund(OrderBO orderBO) {
            orderBO.setRefundSupport(Boolean.FALSE);
        }
    }
    
    // B类型订单退款策略
    @Component
    public class TypeBRefundStrategy implements RefundStrategy {
    
        @Override
        public void supportRefund(OrderBO orderBO) {
            orderBO.setRefundSupport(Boolean.TRUE);
        }
    }
    
    // C类型订单退款策略
    @Component
    public class TypeCRefundStrategy implements RefundStrategy {
    
        @Override
        public void supportRefund(OrderBO orderBO) {
            orderBO.setRefundSupport(Boolean.TRUE);
        }
    }
    
    // 退款策略工厂
    @Component
    public class RefundStrategyFactory implements InitializingBean {
        private Map<String, RefundStrategy> strategyMap = new HashMap<>();
    
        @Resource
        private TypeARefundStrategy typeARefundStrategy;
        @Resource
        private TypeBRefundStrategy typeBRefundStrategy;
        @Resource
        private TypeCRefundStrategy typeCRefundStrategy;
    
        @Override
        public void afterPropertiesSet() throws Exception {
            strategyMap.put(OrderTypeEnum.A_TYPE.getCode(), typeARefundStrategy);
            strategyMap.put(OrderTypeEnum.B_TYPE.getCode(), typeBRefundStrategy);
            strategyMap.put(OrderTypeEnum.C_TYPE.getCode(), typeCRefundStrategy);
        }
    
        public RefundStrategy getStrategy(String type) {
            return strategyMap.get(type);
        }
    }
    
    // 退款策略执行器
    @Component
    public class RefundStrategyExecutor {
        private RefundStrategyFactory refundStrategyFactory;
    
        public void supportRefund(OrderBO orderBO) {
            RefundStrategy refundStrategy = refundStrategyFactory.getStrategy(orderBO.getType());
            if (null == refundStrategy) {
                throw new RuntimeException("无退款策略");
            }
            refundStrategy.supportRefund(orderBO);
        }
    }
    

    3.2 横向做编排

    横向维度表示场景,一种订单类型在广义上可以认为是一种业务场景,在场景中我们要将独立的策略进行串联,模板方法设计模式适用于这种场景。

    模板方法模式定义一个操作中的算法骨架,一般使用抽象类定义算法骨架。抽象类同时定义一些抽象方法,这些抽象方法延迟到子类实现,这样子类不仅遵守了算法骨架约定,也实现了自己的算法。既保证了规约也兼顾灵活性。这就是用抽象构建框架,用实现扩展细节。

    // 创建订单服务
    public interface CreateOrderService {
        public void createOrder(OrderBO orderBO);
    }
    
    // 抽象创建订单流程
    public abstract class AbstractCreateOrderFlow {
    
        @Resource
        private OrderMapper orderMapper;
    
        public void createOrder(OrderBO orderBO) {
            // 参数校验
            if (null == orderBO) {
                throw new RuntimeException("参数异常");
            }
            if (OrderTypeEnum.isNotValid(orderBO.getType())) {
                throw new RuntimeException("参数异常");
            }
            // 计算优惠
            discount(orderBO);
            // 计算重量
            weighing(orderBO);
            // 退款支持
            supportRefund(orderBO);
            // 保存数据
            OrderDO orderDO = new OrderDO();
            BeanUtils.copyProperties(orderBO, orderDO);
            orderMapper.insert(orderDO);
        }
    
        public abstract void discount(OrderBO orderBO);
    
        public abstract void weighing(OrderBO orderBO);
    
        public abstract void supportRefund(OrderBO orderBO);
    }
    
    // 实现创建订单流程
    @Service
    public class CreateOrderFlow extends AbstractCreateOrderFlow {
    
        @Resource
        private DiscountStrategyExecutor discountStrategyExecutor;
        @Resource
        private ExpressStrategyExecutor expressStrategyExecutor;
        @Resource
        private RefundStrategyExecutor refundStrategyExecutor;
    
        @Override
        public void discount(OrderBO orderBO) {
            discountStrategyExecutor.discount(orderBO);
        }
    
        @Override
        public void weighing(OrderBO orderBO) {
            expressStrategyExecutor.weighing(orderBO);
        }
    
        @Override
        public void supportRefund(OrderBO orderBO) {
            refundStrategyExecutor.supportRefund(orderBO);
        }
    }
    

    3.3 复杂架构设计

    上述实例业务和代码并不复杂,其实复杂业务场景也不过是简单场景的叠加和交织,我们无外乎也是通过纵向做隔离、横向做编排寻求答案。

    07 纵向隔离横向编排.jpg

    纵向维度抽象出能力池这个概念,能力池中有一个一个能力,不同的能力按照不同业务维度聚合,例如优惠能力池,物流能力池,退款能力池。我们可以看到两种程度的隔离性,能力池之间相互隔离,能力之间也相互隔离。

    横向维度将能力从能力池选出来,按照业务需求串联在一起,形成不同业务流程。因为能力可以任意组合,所以体现了很强的灵活性。除此之外,不同能力既可以串行执行,如果不同能力之间没有依赖关系,也可以如同流程Y一样并行执行,提升执行效率。


    4 数据分片如何应用纵横思维

    现在有一个电商数据库存放订单、商品、支付三张业务表。随着业务量越来越大,这三张业务数据表也越来越大,查询性能显著降低,数据拆分势在必行。那么数据拆分可以从纵向和横向两个维度进行。


    4.1 纵向分表

    纵向拆分就是按照业务拆分,我们将电商数据库拆分成三个库,订单库、商品库。支付库,订单表在订单库,商品表在商品库,支付表在支付库。这样每个库只需要存储本业务数据,物理隔离不会互相影响。

    02 纵向分表.jpg


    4.2 横向分表

    按照纵向拆分方案,现在我们已经有三个库了,平稳运行了一段时间。但是随着业务增长,每个单库单表的数据量也越来越大,逐渐到达瓶颈。

    这时我们就要对数据表进行横向拆分,所谓横向拆分就是根据某种规则将单库单表数据分散到多库多表,从而减小单库单表的压力。

    横向拆分策略有很多方案,最重要的一点是选好ShardingKey,也就是按照哪一列进行拆分,怎么分取决于我们访问数据的方式。


    4.2.1 范围分片

    如果我们选择的ShardingKey是订单创建时间,那么分片策略是拆分四个数据库,分别存储每季度数据,每个库包含三张表,分别存储每个月数据:

    03 横向分表_范围分表.jpg

    这个方案的优点是对范围查询比较友好,例如我们需要统计第一季度的相关数据,查询条件直接输入时间范围即可。这个方案的问题是容易产生热点数据。例如双11当天下单量特别大,就会导致11月这张表数据量特别大从而造成访问压力。


    4.2.2 查表分片

    查表法是根据一张路由表决定ShardingKey路由到哪一张表,每次路由时首先到路由表里查到分片信息,再到这个分片去取数据。我们分析一个查表法思想应用实际案例。

    Redis官方在3.0版本之后提供了集群方案RedisCluster,其中引入了哈希槽(slot)这个概念。一个集群固定有16384个槽,在集群初始化时这些槽会平均分配到Redis集群节点上。每个key请求最终落到哪个槽计算公式是固定的:

    SLOT = CRC16(key) mod 16384
    

    一个key请求过来怎么知道去哪台Redis节点获取数据?这就要用到查表法思想:

    (1) 客户端连接任意一台Redis节点,假设随机访问到节点A
    (2) 节点A根据key计算出slot值
    (3) 每个节点都维护着slot和节点映射关系表
    (4) 如果节点A查表发现该slot在本节点,直接返回数据给客户端
    (5) 如果节点A查表发现该slot不在本节点,返回给客户端一个重定向命令,告诉客户端应该去哪个节点请求这个key的数据
    (6) 客户端向正确节点发起连接请求
    

    查表法方案优点是可以灵活制定路由策略,如果我们发现有的分片已经成为热点则修改路由策略。缺点是多一次查询路由表操作增加耗时,而且路由表如果是单点也可能会有单点问题。


    4.2.3 哈希分片

    现在比较流行的分片方法是哈希分片,相较于范围分片,哈希分片可以较为均匀将数据分散在数据库中。我们现在将订单库拆分为4个库编号为[0,3],每个库包含3张表编号为[0,2],如下图如所示:

    04 横向分表_哈希分表_1.jpg

    我们选择使用orderId作为ShardingKey,那么orderId=100这个订单会保存在哪张表?因为是分库分表,第一步确定路由到哪一个库,取模计算结果表示库表序号:

    db_index = 100 % 4 = 0
    

    第二步确定路由到哪一张表:

    table_index = 100 % 3 = 1
    

    第三步数据路由到0号库1号表:

    04 横向分表_哈希分表_2.jpg

    在实际开发中路由逻辑并不需要我们手动实现,因为有许多开源框架通过配置就可以实现路由功能,例如ShardingSphere、TDDL框架等等。


    5 文章总结

    复杂问题不过是简单问题的组合和交织,横向和纵向维度拆分问题不失为一种好方法。纵向做隔离是指将不同业务形态进行隔离,能力池之间进行隔离,能力之间也进行隔离。横向做编排是指从能力池中灵活选择能力,进行组合和编排,形成各异的业务流程。希望本文对大家有所帮助。

    欢迎大家关注公众号「JAVA前线」查看更多精彩分享文章,主要包括源码分析、实际应用、架构思维、职场分享、产品思考等等,同时欢迎大家加我个人微信「java_front」一起交流学习

    展开全文
  • 横向拆分与纵向拆分

    千次阅读 2019-03-17 20:55:59
    表的拆分分为横向拆分(记录的拆分)和纵向拆分(字段的拆分)。拆分表的目的:提高查询速度。  1.横向拆分  我们从一个案例去解释,情景是这样的:某某博客,有50W的博客量,有2w的用户,发现随着用户和博客数的...

    表的拆分分为横向拆分(记录的拆分)和纵向拆分(字段的拆分)。拆分表的目的:提高查询速度。
      1.横向拆分

        我们从一个案例去解释,情景是这样的:某某博客,有50W的博客量,有2w的用户,发现随着用户和博客数的增加,查询速度日渐下降,现在要对博客表blog与用户表user进行优化。

      表结构如下:

    复制代码
     1 create table blog(
     2         bid
     3         title
     4         content
     5         pubtime
     6         uid
     7     ) 50万
     8 create table user(
     9         uid
    10         username
    11         password
    12         nick
    13         ......
         )  2万


    首先我们要决定根据哪个字段对记录进行拆分,查询决定了拆分,在这里我们根据uid字段对两个表进行拆分是比较合理的。

     

    复制代码
     1 博客表根据uid去拆分:
     2     1-5000------blog_1
     3     5001-10000-----blog_2
     4     10001-15000----blog_3
     5     15001-20000----blog_4
     6 人员表根据uid 等分:
     7     1-5000------user_1
     8     5001-10000-----user_2
     9     10001-15000----user_3
    10     15001-20000----user_4  
    复制代码
     

      查询某人的博客:

    1 根据uid确认表名:
    2     $num=ceil(12345/5000);
    3     select uid,bid,title,pubtime from blog_$num where uid=12345;
      2.纵向拆分:把活跃字段(常用)、惰性字段(不常用)分开。

       案例:比如人员表,活跃字段像用户名、密码、昵称等,惰性字段像手机号、邮箱、性别等不经常使用和修改的字段。

      一张完整的用户表可以拆分为两张表,如下:

    复制代码
     1 create table user(
     2     uid int key auto_increment,
     3     username char(20),
     4     password char(32) not null, 
     5     nick char(10)
     6 );
     7 create table user_ext(
     8     uid
     9     regtime
    10     name
    11     email
    12     qq
    13     phone
    14     sex    
    15 )
    复制代码

    展开全文
  • 数据库中同一张表int类型同一行字段相加 select IFNULL(c1,0) +IFNULL(c2,0) from table where Id = 1 (IFNULL(C1,0)中的0表示如果c1为null则将c1设置为0.之前没有加报错了) 数据库中同一张表int类型同一列...


    数据库中同一张表int类型同一行字段相加
    select IFNULL(c1,0) +IFNULL(c2,0) from tableName where Id = 1   (IFNULL(C1,0)中的0表示如果c1为null则将c1设置为0.之前没有加报错了)




    数据库中同一张表int类型同一列字段相加
    SELECT sum( jine ) FROM `dingdan` WHERE `un` = '3333333333333'"
    展开全文
  • 让我们从普遍的情况来考虑数据的切分:一方面,一个库的所有表通常不可能由某一张表全部串联起来,这句话暗含的意思是,水平切分几乎都是针对一小搓一小搓(实际上就是垂直切分出来的块)关系紧密的表进行的,而不...
  • 数据库的横向纵向分表

    千次阅读 2018-04-02 13:25:01
    2、纵向分表对于互联网公司来讲,数据有可能是几亿级别,如果在一个数据库的一张表中存储,数据库可能运转不过来,可以通过取模的方式来分成多个数据库和多张相同的表来减少每张表的数据量,提高性能。...
  • 也是一张,这难不倒小久,依旧是打印预览,左侧边框有纸张选择,我们可以选择纸张大小和横向纵向,看个人需求而定。 可以看到预览依旧是好几张,还很凌乱 这个时候呢,重点来了,纸张下面有个页面设置,我们打开它,...
  • 有时候做项目过程中,设计的是一张横向的长图,但是我们需要在手机端观看的时候,也想把手机横着观看,这样视野更宽阔,如何解决这个问题呢? html <div class="imgBox"> </div> css ....
  • 本文实例为大家分享了python实现图片横向纵向拼接的具体代码, 这里主要用Python扩展库pillow中Image对象的paste()方法把两张图片拼接起来供大家参考,具体内容如下: 一、代码: from PIL import Image def...
  • 表的拆分分为横向拆分(记录的拆分)和纵向拆分(字段的拆分)。拆分表的目的:提高查询速度。  1.横向拆分  我们从一个案例去解释,情景是这样的:某某博客,有50W的博客量,有2w的用户,发现随着用户和博客数...
  • sql server把横向数据列表转为纵向

    千次阅读 2019-06-26 16:06:06
    有个一张表:学员成绩表student 字段如下:id,name,cscore,cgrade,mscore,mgrade,escore,egrade ...如何把横向数据列表转为纵向? 如下图的效果 代码如下 最后查询出的结果如下: ...
  • 一、横向(两个) /**  * 横向拼接  * &lt;功能详细描述&gt;  * @param first  * @param second  * @return  */  private Bitmap add2Bitmap(Bitmap first, Bitmap second) {  int width = first....
  • Oracle横向纵向求和

    千次阅读 2016-09-08 15:18:04
    一张工资表SALARY如下, (NO 员工编号 ,MONEY 工资) NO NAME ITEM MONEY 001 张三 工资 80  001 张三 补贴 86  001 张三 奖金 75  002 李四 工资 78 
  • 设计了一张标签,要打印的内容是纵向的,要打印在 宽*高=8cm*10cm 的标签纸上,结果在设计完后发现客户购买的是 宽*高=10cm*8cm 的标签纸,于是就尝试使用 e.PageSettings.Landscape = true 来进行横向打印,结果...
  • 编写一条sql语句将表1(stuScore)中的纵向排列数据改写成表2 表1(stuScore): id stuName courseName score 1 大李 语文 99.5 2 大李 数学 79.5 3 大李 英语 49.5 4...
  • 将数据表的纵向数据横向显示

    千次阅读 2015-06-08 11:22:19
    有时为了使数据记录显示的更直观,会需要将记录横向显示。例如航空公司仓位数据表有这样的记录(如图所示):    是不是感觉很难快速看完,在这些数据中每个航空公司都是重复的,不易理解。为了解决这个问题...
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等)请往我的资源...
  • Word软件信息:Office2007 步骤一:假设当前页为横向页。通过“Ctrl+Enter”键插入新的一页 步骤二:选中插入页(如下图所示),进入“页面布局”菜单,点击“页面设置...备注:在横向页中插入纵向页的操作方法类似。
  • Java横向纵向合并图片

    千次阅读 2014-07-04 21:33:24
    进行图片对比时候想把两张有差异的图片放到一起,方便人工查看下,在网上搜了一些,有纵向合并的。 将纵向合并的自己调整了下,源码如下:   import java.io.File; import java.awt.image.BufferedImage; ...
  • python图片排列 横向纵向同时

    千次阅读 2019-06-12 09:55:49
    import PIL.Image as Image import os toImage = Image.new('RGB', (640 * 3, 480 * 3)) # 构造图片的宽和高,如果图片不能填充完全会 dir_root = "C:/Users/JIA/Desktop/PG2019论文素材/柱状图" ...
  • Oracle横向纵向汇总

    千次阅读 2013-10-12 10:27:09
    一张表test 如下, (NO 学生编号 ,cj 成绩) NO name KM CJ 001 张三 语文 80  001 张三 数学 86  001 张三 英语 75  002 李四 语文 78  002 李四 数学 85  002 李四 英语 78 写了以下语句来算每项个科目的...
  • Python将两张图片按横向纵向拼接成一张图片

    万次阅读 热门讨论 2021-05-14 12:34:16
    path1 = r"D:/photo1/1.png" path2 = r"D:/photo1/2.png" # 横向拼接 #pic_joint(path1, path2, flag='horizontal') # 纵向拼接 pic_joint(path1, path2, flag='vertical') 效果展示 总结 应用场景: 扫描后的身份证...
  • finereport 跨sheet取单元格数据之被取sheet有横向纵向同时扩展 适用情景:被取数sheet表格存在横向纵向同时扩展,标题横向,内容纵向扩展。 情景描述图: finereport 社区解决的只有重现扩展情况,但是两种...
  • 有时候做项目过程中,设计的是一张横向的长图,但是我们需要在手机端观看的时候,也想把手机横着观看,这样视野更宽阔,如何解决这个问题呢? html <div class="imgBox"> </div> css .imgBox ...
  • 1. 纵向分表 纵向分表是指将一个有20列的表根据列拆分成两个表一个表10列一个表11列,这样单个表的容量就会减少很多,可以提高查询的性能,并在一定程度上减少锁行,锁表带来的性能损耗。 纵向分表的原则是什么呢,...
  • 需求:把一个表某个字段内容复制到另一张表的某个字段。 实现sql语句1: 代码如下:UPDATE file_manager_folder f1LEFT OUTER JOIN file_manager_folder f2 ON f1.name = f2.name AND f2.parentId = 54SET f1.parentId...
  • Oracle之纵向数据转换横向数据

    千次阅读 2014-07-25 11:07:33
    一张薪资表为例,表结构如下: 表结构中,每个员工id对应有多个薪资项目以及金额,需要查询时转向,将每个员工的薪资项目转为横向一行显示。 在直接查询(加入一些限制条件以缩小结果集), ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,272
精华内容 7,308
关键字:

一张横向一张纵向