V2EX = way to explore
V2EX 是一个关于分享和探索的地方
现在注册
已注册用户请  登录
? MySQL 5.5 Community Server
? MySQL 5.6 Community Server
? Percona Configuration Wizard
? XtraBackup 搭建主从复制
Great Sites on MySQL
? Percona
? MySQL Performance Blog
? Severalnines
推荐管理工具
? Sequel Pro
? phpMyAdmin
推荐书目
? MySQL Cookbook
MySQL 相关项目
? MariaDB
? Drizzle
参考文档
? http://mysql-python.sourceforge.net/MySQLdb.html
funbox
V2EX  ?  MySQL

日常涨知识系列-惊天地泣鬼神的 sql, 300 行~~

  •  3
     
  •   funbox · 2020-12-23 14:19:12 +08:00 · 13340 次点击
    这是一个创建于 1225 天前的主题,其中的信息可能已经有所发展或是发生改变。

    腾讯云最新优惠活动来了:云产品限时1折,云服务器低至88元/年 ,点击这里立即抢购:9i0i.cn/qcloud,更有2860元代金券免费领取,付款直接抵现金用,点击这里立即领取:9i0i.cn/qcloudquan

    (福利推荐:你还在原价购买阿里云服务器?现在阿里云0.8折限时抢购活动来啦!4核8G企业云服务器仅2998元/3年,立即抢购>>>:9i0i.cn/aliyun

    没有别的意思就是想让大家,长长见识~ 能看懂算我输

    SELECT
    	* 
    FROM
    	(
    	SELECT
    		`inventory`.`id` AS `inventoryId`,
    		`inventory`.`location_id` AS `locationId`,
    		`inventory`.`storehouse_id` AS `storehouseId`,
    		`product`.`id` AS `productId`,
    		`product`.`name` AS `name`,
    		`product`.`number` AS `number`,
    		`brand`.`name` AS `brandName`,
    		`product`.`size` AS `size`,
    		`category`.`name` AS `categoryName`,
    		`product`.`unit` AS `unit`,
    		`storehouse`.`name` AS `storehouseName`,
    		`location`.`name` AS `locationName`,
    		IFNULL( inventory.quantity, 0 ) AS `remainQuantity`,
    		IFNULL( inventoryBath.avgPrice, 0 ) AS `avgPrice`,
    		IFNULL( inventoryBath.totalPrice, 0 ) AS `totalPrice`,
    		`inventoryWarning`.`lowerLimit` AS `lowerLimit`,
    		`inventoryWarning`.`upperLimit` AS `upperLimit`,(
    			IFNULL( repairOrderItem.repairRemainQuantity, 0 )+ IFNULL( purchaseReturnOrderItem.purchaseReturnRemainQuantity, 0 )+ IFNULL( otherOutOrderItem.otherInOutstockQuantity, 0 )) AS `waitOutQuantity`,(
    		IFNULL( purchaseOrderItem.purchaseRemainQuantity, 0 )+ IFNULL( otherInOrderItem.otherInOutstockQuantity, 0 )+ IFNULL( onlineInOrderItem.onlineRemainInstockQuantity, 0 )) AS `waitIntQuantity`,
    		`product`.`barcode` AS `barcode`,
    		`supplier`.`name` AS `supplierName`,
    		`product`.`valid_period` AS `validPeriod`,
    		`product`.`standard_id` AS `standardId`,
    		`product`.`from_id` AS `fromId`,
    		`product`.`source` AS `source`,
    		`oeTable`.`oeNumber` AS `oeNumber`,
    		`product`.`vehicle_note` AS `vehicleNote`,
    		`product`.`description` AS `note`,
    		`store`.`name` AS `storeName`,
    		`product`.`create_time` AS `createTime`,
    		`inventory`.`tenant_id`,
    		`product`.`sale_price1` AS `productSalePrice`,
    		`product`.`price_mode` AS `productPriceMode`,
    		`product`.`markup_type` AS `productMarkupType`,
    		IFNULL( lastPurchasePrice.lastPurchasePrice, 0 ) AS `lastPurchasePrice`,(
    		CASE
    				
    				WHEN product.price_mode = 1 THEN
    				product.sale_price1 
    				WHEN product.price_mode = 2 
    				AND product.markup_type = 1 
    				AND IFNULL( inventory.quantity, 0 )= 0 THEN
    					IFNULL( lastOutPrice.unitPrice, 0 )* product.sale_price1 
    					WHEN product.price_mode = 2 
    					AND product.markup_type = 1 
    					AND IFNULL( inventory.quantity, 0 ) != 0 THEN
    						IFNULL( inventoryBath.avgPrice, 0 )* product.sale_price1 
    						WHEN product.price_mode = 2 
    						AND product.markup_type != 1 THEN
    							IFNULL( lastPurchasePrice.lastPurchasePrice, 0 )* product.sale_price1 
    						END 
    						) AS salePrice 
    					FROM
    						`inventory`
    						LEFT JOIN `product` ON `inventory`.`product_id` = `product`.`id`
    						LEFT JOIN `category` ON `product`.`category_id` = `category`.`id`
    						LEFT JOIN `brand` ON `product`.`brand_id` = `brand`.`id`
    						LEFT JOIN `storehouse` ON `inventory`.`storehouse_id` = `storehouse`.`id`
    						LEFT JOIN `location` ON `inventory`.`location_id` = `location`.`id`
    						LEFT JOIN `supplier` ON `product`.`supplier_id` = `supplier`.`id`
    						LEFT JOIN `store` ON `inventory`.`store_id` = `store`.`id`
    						LEFT JOIN (
    						SELECT
    							SUBSTRING_INDEX(
    								GROUP_CONCAT( unit_price ORDER BY outstock_time DESC ),
    								',',
    								1 
    							) AS `unitPrice`,
    							`product_id` AS `productId` 
    						FROM
    							`inventory_batch` 
    						WHERE
    							( `store_id` = '27358' ) 
    							AND ( `inventory_batch`.`tenant_id` = 1 ) 
    						GROUP BY
    							`product_id` 
    						) `lastOutPrice` ON `inventory`.`product_id` = lastOutPrice.productId
    						LEFT JOIN (
    						SELECT
    							group_concat( product_number.number SEPARATOR ";" ) AS `oeNumber`,
    						`product_number`.`product_id` AS `productId` 
    						FROM
    							`product_number` 
    						WHERE
    							( `product_number`.`type` = 1 ) 
    							AND ( `product_number`.`tenant_id` = 1 ) 
    						GROUP BY
    							`product_number`.`product_id` 
    						) `oeTable` ON `inventory`.`product_id` = oeTable.productId
    						LEFT JOIN (
    						SELECT
    							`storehouse_id` AS `storehouseId`,
    							SUM( quantity )- SUM( outstock_quantity ) AS `remainQuantity`,
    							SUM(
    								unit_price *(
    									quantity - outstock_quantity 
    								)) AS `totalPrice`,
    							`product_id` AS `productId`,
    						IF
    							(
    								inventoryBathAll.currentQuantity = 0,
    								inventoryBathLast.unitPrice,
    							round( inventoryBathAll.avgPrice, 2 )) AS `avgPrice` 
    						FROM
    							`inventory_batch`
    							LEFT JOIN (
    							SELECT
    								`product_id` AS `productId`,
    								SUM( quantity )- SUM( outstock_quantity ) AS `currentQuantity`,
    								CONVERT (
    									SUM(
    										unit_price *(
    											quantity - outstock_quantity 
    										))/(
    									SUM( quantity )- SUM( outstock_quantity )),
    								DECIMAL ( 20, 2 )) AS `avgPrice` 
    							FROM
    								`inventory_batch` 
    							WHERE
    								( `store_id` = '27358' ) 
    								AND ( `inventory_batch`.`tenant_id` = 1 ) 
    							GROUP BY
    								`product_id` 
    							) `inventoryBathAll` ON `inventory_batch`.`product_id` = inventoryBathAll.productId
    							LEFT JOIN (
    							SELECT
    								SUBSTRING_INDEX(
    									GROUP_CONCAT( unit_price ORDER BY batch_number DESC ),
    									",",
    									1 
    								) AS `unitPrice`,
    								`product_id` AS `productId`,
    								max( batch_number ) AS `batchNumber` 
    							FROM
    								`inventory_batch` 
    							WHERE
    								( `store_id` = '27358' ) 
    								AND ( `inventory_batch`.`tenant_id` = 1 ) 
    							GROUP BY
    								`product_id` 
    							ORDER BY
    								`batch_number` DESC 
    							) `inventoryBathLast` ON `inventory_batch`.`product_id` = inventoryBathLast.productId 
    						WHERE
    							( `store_id` = '27358' ) 
    							AND ( `inventory_batch`.`tenant_id` = 1 ) 
    						GROUP BY
    							`product_id`,
    							`storehouse_id` 
    						) `inventoryBath` ON ( `inventory`.`product_id` = inventoryBath.productId ) 
    						AND ( `inventory`.`storehouse_id` = inventoryBath.storehouseId )
    						LEFT JOIN (
    						SELECT
    							`product_id` AS `productId`,
    							`lower_limit` AS `lowerLimit`,
    							`upper_limit` AS `upperLimit` 
    						FROM
    							`inventory_warning` 
    						WHERE
    							( `store_id` = '27358' ) 
    						AND ( `inventory_warning`.`tenant_id` = 1 )) `inventoryWarning` ON `inventory`.`product_id` = inventoryWarning.productId
    						LEFT JOIN (
    						SELECT
    							SUM( repair_order_product_item.quantity - repair_order_product_item.use_quantity ) AS `repairRemainQuantity`,
    							`repair_order_product_item`.`product_id` AS `productId` 
    						FROM
    							`repair_order_product_item`
    							INNER JOIN (
    							SELECT
    								* 
    							FROM
    								`repair_order` 
    							WHERE
    								( `status` != 21000 ) 
    								AND ( `repair_order`.`store_id` = '27358' ) 
    							AND ( `repair_order`.`tenant_id` = 1 )) `repairOrder` ON `repair_order_product_item`.`order_id` = repairOrder.id
    							INNER JOIN (
    							SELECT DISTINCT
    								`product_id` 
    							FROM
    								`inventory` 
    							WHERE
    								( `store_id` = '27358' ) 
    								AND ( `inventory`.`tenant_id` = 1 ) 
    							GROUP BY
    								`product_id` 
    							) `inventoryQue` ON `repair_order_product_item`.`product_id` = inventoryQue.product_id 
    						WHERE
    							`repair_order_product_item`.`tenant_id` = 1 
    						GROUP BY
    							`repair_order_product_item`.`product_id` 
    						) `repairOrderItem` ON `inventory`.`product_id` = repairOrderItem.productId
    						LEFT JOIN (
    						SELECT
    							SUM( purchase_return_order_item.quantity - purchase_return_order_item.outstock_quantity ) AS `purchaseReturnRemainQuantity`,
    							`purchase_return_order_item`.`product_id` AS `productId` 
    						FROM
    							`purchase_return_order_item`
    							INNER JOIN (
    							SELECT
    								* 
    							FROM
    								`purchase_return_order` 
    							WHERE
    								(
    								`purchase_return_order`.`status` IN ( 12000, 13000 )) 
    								AND ( `purchase_return_order`.`store_id` = '27358' ) 
    							AND ( `purchase_return_order`.`tenant_id` = 1 )) `purchaseReturnOrder` ON `purchase_return_order_item`.`order_id` = purchaseReturnOrder.id 
    						WHERE
    							`purchase_return_order_item`.`tenant_id` = 1 
    						GROUP BY
    							`purchase_return_order_item`.`product_id` 
    						) `purchaseReturnOrderItem` ON `inventory`.`product_id` = purchaseReturnOrderItem.productId
    						LEFT JOIN (
    						SELECT
    							SUM( other_in_out_stock_order_item.quantity ) AS `otherInOutstockQuantity`,
    							`other_in_out_stock_order_item`.`product_id` AS `productId` 
    						FROM
    							`other_in_out_stock_order_item`
    							INNER JOIN (
    							SELECT
    								* 
    							FROM
    								`other_in_out_stock_order` 
    							WHERE
    								( `other_in_out_stock_order`.`type` = 1 ) 
    								AND ( `other_in_out_stock_order`.`status` = 1 ) 
    								AND ( `other_in_out_stock_order`.`store_id` = '27358' ) 
    							AND ( `other_in_out_stock_order`.`tenant_id` = 1 )) `otherInOutOrder` ON `other_in_out_stock_order_item`.`order_id` = otherInOutOrder.id 
    						WHERE
    							`other_in_out_stock_order_item`.`tenant_id` = 1 
    						GROUP BY
    							`other_in_out_stock_order_item`.`product_id` 
    						) `otherOutOrderItem` ON `inventory`.`product_id` = otherOutOrderItem.productId
    						LEFT JOIN (
    						SELECT
    							SUM( purchase_order_item.quantity - purchase_order_item.instock_quantity ) AS `purchaseRemainQuantity`,
    							`purchase_order_item`.`product_id` AS `productId` 
    						FROM
    							`purchase_order_item`
    							INNER JOIN (
    							SELECT
    								* 
    							FROM
    								`purchase_order` 
    							WHERE
    								(
    								`purchase_order`.`status` IN ( 12000, 13000 )) 
    								AND ( `purchase_order`.`store_id` = '27358' ) 
    							AND ( `purchase_order`.`tenant_id` = 1 )) `purchaseOrder` ON `purchase_order_item`.`order_id` = purchaseOrder.id 
    						WHERE
    							`purchase_order_item`.`tenant_id` = 1 
    						GROUP BY
    							`purchase_order_item`.`product_id` 
    						) `purchaseOrderItem` ON `inventory`.`product_id` = purchaseOrderItem.productId
    						LEFT JOIN (
    						SELECT
    							SUM( other_in_out_stock_order_item.quantity ) AS `otherInOutstockQuantity`,
    							`other_in_out_stock_order_item`.`product_id` AS `productId` 
    						FROM
    							`other_in_out_stock_order_item`
    							INNER JOIN (
    							SELECT
    								* 
    							FROM
    								`other_in_out_stock_order` 
    							WHERE
    								( `other_in_out_stock_order`.`type` = 2 ) 
    								AND ( `other_in_out_stock_order`.`status` = 1 ) 
    								AND ( `other_in_out_stock_order`.`store_id` = '27358' ) 
    							AND ( `other_in_out_stock_order`.`tenant_id` = 1 )) `otherInOutOrder` ON `other_in_out_stock_order_item`.`order_id` = otherInOutOrder.id 
    						WHERE
    							`other_in_out_stock_order_item`.`tenant_id` = 1 
    						GROUP BY
    							`other_in_out_stock_order_item`.`product_id` 
    						) `otherInOrderItem` ON `inventory`.`product_id` = otherInOrderItem.productId
    						LEFT JOIN (
    						SELECT
    							SUM( online_purchase_order_item.quantity - online_purchase_order_item.instock_quantity ) AS `onlineRemainInstockQuantity`,
    							`online_purchase_order_item`.`product_id` AS `productId` 
    						FROM
    							`online_purchase_order_item`
    							INNER JOIN (
    							SELECT
    								* 
    							FROM
    								`online_purchase_order` 
    							WHERE
    								( `online_purchase_order`.`status` = 1 ) 
    								AND ( `online_purchase_order`.`store_id` = '27358' ) 
    							AND ( `online_purchase_order`.`tenant_id` = 1 )) `onlineOrder` ON `online_purchase_order_item`.`order_id` = onlineOrder.id 
    						WHERE
    							`online_purchase_order_item`.`tenant_id` = 1 
    						GROUP BY
    							`online_purchase_order_item`.`product_id` 
    						) `onlineInOrderItem` ON `inventory`.`product_id` = onlineInOrderItem.productId
    						LEFT JOIN (
    						SELECT
    							`product_id` AS `productId`,
    							`last_price` AS `lastPurchasePrice` 
    						FROM
    							`purchase_price` 
    						WHERE
    							( `store_id` = '27358' ) 
    						AND ( `purchase_price`.`tenant_id` = 1 )) `lastPurchasePrice` ON `inventory`.`product_id` = lastPurchasePrice.productId 
    					WHERE
    						( `product`.`status` != 90 ) 
    						AND ( `inventory`.`store_id` = '27358' ) 
    					AND ( `inventory`.`tenant_id` = 1 )) `table` 
    				WHERE
    					`table`.`tenant_id` = 1 
    				ORDER BY
    				`createTime` DESC 
    	LIMIT 10
    
    第 1 条附言  ·  2020-12-24 09:24:22 +08:00
    主要是这个 sql 是 mysql 慢日志里面搜出来的
    业务是前端界面 用户可以任意点击。。。。
    109 条回复  ?  2020-12-25 16:51:06 +08:00
    1  2  
    ? ?
    ttys001
        1
    ttys001  
       2020-12-23 14:23:42 +08:00   ?? 1
    sql 不用维护吧,不用吧,不用吧……
    funbox
        2
    funbox  
    OP
       2020-12-23 14:24:33 +08:00
    @ttys001 最近优化碰到的,生产环境!!!
    hack2012
        3
    hack2012  
       2020-12-23 14:24:47 +08:00
    这个估计是 dba 写的。
    totoro52
        4
    totoro52  
       2020-12-23 14:25:51 +08:00   ?? 5
    ........写这种 SQL 的也是人才 好家伙直接在 sql 里写业务逻辑
    ben1024
        5
    ben1024  
       2020-12-23 14:26:32 +08:00
    emm... 能说正常操作吗,在处理数据聚合时根本不知道会写多长的 SQL
    melvin
        6
    melvin  
       2020-12-23 14:27:18 +08:00
    真特么人才 几秒输出结果
    cslive
        7
    cslive  
       2020-12-23 14:27:51 +08:00
    见多了,都是从数仓抽数的
    kiracyan
        8
    kiracyan  
       2020-12-23 14:28:34 +08:00
    虽然是屎山 但是整理好应该能看懂的
    learningman
        9
    learningman  
       2020-12-23 14:31:55 +08:00   ?? 4
    不错了,都是英文,结合业务看看就懂
    如果把以上都换成拼音首字母,你直接跳楼更干脆些
    lovecy
        10
    lovecy  
       2020-12-23 14:35:27 +08:00
    其实结构还挺简单的,LEFT JOIN 一堆表,然后从生成的临时表用 WHERE 抽数,看是能看懂,改起来就痛苦了,最好祈祷不要出问题。。。
    czzt1
        11
    czzt1  
       2020-12-23 14:36:47 +08:00   ?? 1
    这才几行,几千行的存储过程写的业务逻辑见过么
    acr0ss
        12
    acr0ss  
       2020-12-23 14:37:03 +08:00
    结构清晰的,但是理解逻辑就难了。
    好在每个 join structure 的 table alias 起名挺用心,意义很明确;在没有注释的情况下,能给出不少提示。
    securityCoding
        13
    securityCoding  
       2020-12-23 14:37:28 +08:00
    @melvin 应该是在数仓跑的
    joesonw
        14
    joesonw  
       2020-12-23 14:41:05 +08:00   ?? 1
    BI 里面不都这么写的吗? 还是这个是业务环境
    funbox
        15
    funbox  
    OP
       2020-12-23 14:42:54 +08:00
    @cslive 主要是用户前端点击列表的 sql 。。。。。
    tojonozomilk
        16
    tojonozomilk  
       2020-12-23 14:46:45 +08:00
    什么?居然有这么简单的 SQL ?——来自数仓开发
    huobazi
        17
    huobazi  
       2020-12-23 14:48:31 +08:00
    几千行的 sp,sp 套 sp,各种传参传 xml 和 json,还不是一个字 ”整“

    这种 sql 都是 先写个 小的,简单的,慢慢加上去的。其实也没啥。

    好的代码都是 helloword,但 helloword 不值钱
    lllllIIIlll
        18
    lllllIIIlll  
       2020-12-23 14:51:40 +08:00
    数据分析那边几百行的 sql 太多了
    taogen
        19
    taogen  
       2020-12-23 15:29:26 +08:00
    某列表页面 SQL,join 20 个,卒
    w292614191
        20
    w292614191  
       2020-12-23 15:30:15 +08:00
    你这个一般般,我们这 C#项目,几百行几百行是基本写法。
    hafuhafu
        21
    hafuhafu  
       2020-12-23 15:33:17 +08:00
    其实还好,我们这里抽取报表数据蛮多很长的。
    FlyingShark
        22
    FlyingShark  
       2020-12-23 15:48:49 +08:00
    这个还好,结构还算清楚、而且别名 alias 容易阅读。也见过 700 行的 SQL,一堆 union all 拼起来……
    roundgis
        23
    roundgis  
       2020-12-23 15:56:00 +08:00 via Android
    @czzt1 前東家的系統是兩層架構,客戶端直連數據庫,核心代碼就是那堆存儲過程,隨便一個函數都過萬行代碼
    fhsan
        24
    fhsan  
       2020-12-23 15:59:44 +08:00
    @roundgis 好家伙,台湾公司有钱买了两份 oracle,同步数据、处理数据等等都是 sql 干,要不买了干嘛
    andyskaura
        25
    andyskaura  
       2020-12-23 16:12:17 +08:00
    我们整个项目就是这么开发的 这样的确不好 但是要改吧 快 20 年都这么过来了 没必要
    manami
        26
    manami  
       2020-12-23 16:17:00 +08:00
    你是没见过上千行的一个存储过程
    fanfpy
        27
    fanfpy  
       2020-12-23 16:47:14 +08:00
    存储过程不都这长度吗
    fanfpy
        28
    fanfpy  
       2020-12-23 16:47:32 +08:00
    ![1073bfd22008d0b5439b890c3ca1755.png]( https://i.loli.net/2020/12/23/XL9ERHbihIT6sAB.png)
    526326991
        29
    526326991  
       2020-12-23 16:54:50 +08:00
    做过数据报表表示 正常操作~~~
    fish267
        30
    fish267  
       2020-12-23 16:59:39 +08:00   ?? 6
    这种贴数仓代码,不是违规么,要有程序员基本素养哈
    thtznet
        31
    thtznet  
       2020-12-23 17:04:24 +08:00
    楼主少见多怪,这段 sql 脚本不是 erp 日常么?楼主估计没有从事过企业内信息系统的开发。
    251243021
        32
    251243021  
       2020-12-23 17:04:52 +08:00
    请问这么多行都是怎么读懂且保证修改不出问题的呢
    todd7zhang
        33
    todd7zhang  
       2020-12-23 17:08:02 +08:00
    ERP 里面满天飞
    antiquezzz
        34
    antiquezzz  
       2020-12-23 17:08:28 +08:00
    看着还是挺整齐的,sql 写的挺好的,这样效率高
    xpresslink
        35
    xpresslink  
       2020-12-23 17:10:16 +08:00
    其实这东西难度没多大,只是需要充分理解业务和数据的含义。
    这种东西就象垃圾堆经年累月堆得太高了以后,让人有一触即溃的感觉而已。
    annielong
        36
    annielong  
       2020-12-23 17:11:49 +08:00
    erp 业务类基本操作,只有 cms 类的不怎么用这些
    g76
        37
    g76  
       2020-12-23 17:11:56 +08:00
    长见识了
    potatoyam
        38
    potatoyam  
       2020-12-23 17:19:10 +08:00
    好熟悉看着像理财业务的统计 sql
    a54552239
        39
    a54552239  
       2020-12-23 17:21:41 +08:00
    数据量大了,不会卡吗
    lcdxiangzi
        40
    lcdxiangzi  
       2020-12-23 17:22:39 +08:00
    如果去掉最后一行,会有什么效果?
    iRiven
        41
    iRiven  
       2020-12-23 17:25:03 +08:00
    嵌套多层,可以用 with as 把水平代码拆分成垂直,更好理解。
    lap510200
        42
    lap510200  
       2020-12-23 17:35:35 +08:00
    联了很多张表 嵌套子查询 临时表 效率低下 但是写的人也蛮苦了 至少根据理清业务逻辑写出来这些 sql 加上调试这打断 sql 是否满足需求 这些所花费的时间估计至少 1 天

    除此之外把技术总监拖出去毙了 居然没有代码审核
    sampeng
        43
    sampeng  
       2020-12-23 17:42:37 +08:00
    才 300 行。。见过几千行的么?弟弟。。。
    kisshere
        44
    kisshere  
       2020-12-23 17:42:55 +08:00
    MySQL:你是不是觉得你很幽默?
    KaynW
        45
    KaynW  
       2020-12-23 17:43:42 +08:00
    我只看到了 27358
    quan01994
        46
    quan01994  
       2020-12-23 17:54:39 +08:00
    还好啦
    IrisFrankie
        47
    IrisFrankie  
       2020-12-23 17:57:12 +08:00
    挺整齐的,命名也没啥问题。你理解需求后再读应该会挺简单的。。。不要试图否定它,除非你能优化它
    unicloud
        48
    unicloud  
       2020-12-23 18:00:03 +08:00
    打扰了。。。
    DarkCat123
        49
    DarkCat123  
       2020-12-23 18:04:06 +08:00
    这是人类文明的精华。
    OldHu
        50
    OldHu  
       2020-12-23 18:21:34 +08:00   ?? 4
    见过 sql 保存成文本文件有 2MB 的吗? 你们啊,too naive !

    ERP 系统啥的,长 sql 还是很多的。 所以,ERP 系统大部分还是 Oracle 这种商业数据库多。
    MySQL 是借着互联网起来的。业务相对简单,开发人员多,很多逻辑用开发代码解决,而不是用数据库。

    我以前做 Oracle ERP 的很多业务开发,就是 plsql + shell, 就跟现在后端写 java 一样。

    v2ex 大部分都是互联网从业者为主,还有很多朋友是前端,所以对这样有点 old style 的东西很陌生,陌生了又容易导致反感。
    limuyan44
        51
    limuyan44  
       2020-12-23 18:25:13 +08:00   ?? 1
    才 300 行而已,刚毕业那会写了半年 sql,300 行算是起步了。
    la2la
        52
    la2la  
       2020-12-23 18:25:17 +08:00
    @OldHu 对的,oracle erp 系统,包括之前的一些报表系统,300 行基本操作
    Vegetable
        53
    Vegetable  
       2020-12-23 18:27:23 +08:00
    这个虽然长,但是逻辑不复杂吧,只是字段多而已。
    mengdodo
        54
    mengdodo  
       2020-12-23 18:29:22 +08:00
    牛皮
    yeqizhang
        55
    yeqizhang  
       2020-12-23 18:29:36 +08:00 via Android
    感觉 erp 报表常见,反正数仓数据处理的我是见过写很多行的
    optional
        56
    optional  
       2020-12-23 18:34:58 +08:00 via iPhone
    不说 erp,搞数据分析也觉得这个没什么啊
    Mohanson
        57
    Mohanson  
       2020-12-23 18:40:41 +08:00
    哈哈, 楼主本来想带节奏, 结果楼下一堆人才把楼主描述成一个"没见识的"...
    liuxey
        58
    liuxey  
       2020-12-23 18:54:50 +08:00
    PL/SQL:行数算什么,调用栈堪比 Java
    mamahaha
        59
    mamahaha  
       2020-12-23 18:56:00 +08:00
    这是不想让人抢饭碗吧?升级业务老老实实还得找他。
    Umenezumi
        60
    Umenezumi  
       2020-12-23 21:49:31 +08:00   ?? 1
    数据分析那边儿经常是这种 SQL 啊,这个还算逻辑清晰了
    jasonkayzk
        61
    jasonkayzk  
       2020-12-23 22:07:59 +08:00
    想知道这种 SQL 的性能如何= =
    Felldeadbird
        62
    Felldeadbird  
       2020-12-23 22:24:56 +08:00
    这 SQL 写得很好啊。至少说明 DB 命名上 规范。如果楼主遇到过一推 AS a, b ,c, d...

    我很好奇这代码性能。。。

    最后,楼主直接贴代码,不怕问责吗?
    AntoniotheFuture
        63
    AntoniotheFuture  
       2020-12-23 22:26:37 +08:00
    小意思啦,我之前一个项目一条 SQL3000 行而且有 4 条,跑一个小时,后来我亚索成 1000 行了,运行时间降到 20 分钟
    thetbw
        64
    thetbw  
       2020-12-23 22:30:28 +08:00 via Android
    还好,我们公司 4,5 百行的也有,还是一个 sql 联接 10 多张表的,加上子查询。只能说公司服务器真的强大,还有就是访问量也没有很大,接口速度还能接受
    ZhaoHongXuan
        65
    ZhaoHongXuan  
       2020-12-23 22:36:11 +08:00
    odps 上跑的?
    uselessVisitor
        66
    uselessVisitor  
       2020-12-23 22:55:27 +08:00 via Android
    @roundgis 青铜器我记得就是这样的好像
    kevinjaz
        67
    kevinjaz  
       2020-12-23 23:22:08 +08:00
    我觉得还好呀
    fatestigma
        68
    fatestigma  
       2020-12-23 23:28:04 +08:00
    让我想起了当年上数据库课,几个加分题都是这种上百行的,写完之后过一天就看不懂自己写的啥了
    FieldFarmer
        69
    FieldFarmer  
       2020-12-23 23:43:39 +08:00 via Android
    很多项目直接把业务逻辑写在 oracle 里面的…用存储过程
    Tink
        70
    Tink  
       2020-12-24 00:56:28 +08:00 via Android
    这不是手写的,这绝壁不是
    loading
        71
    loading  
       2020-12-24 01:17:31 +08:00 via Android
    看着挺常规
    AkideLiu
        72
    AkideLiu  
       2020-12-24 01:28:10 +08:00 via iPhone
    Oracle : 别难为 MySQL,有啥事冲我来
    laicanwen
        73
    laicanwen  
       2020-12-24 08:09:40 +08:00 via Android
    我在前公司做 ERP 的时候没有一个存储过程少于 300 行的,而且字段名还是无意义编号,看一个字段查一遍手册。那会要是每个同事写的存储过程能有这样我就谢天谢地了。
    Lancerer
        74
    Lancerer  
       2020-12-24 08:32:42 +08:00
    这玩意在 mybatis 里的 xml 看才是难受,先把他转成 sql 再说吧。。。
    ming7435
        75
    ming7435  
       2020-12-24 08:42:17 +08:00
    我直接就好家伙,这哥们一辈子不会被辞退了,除非公司倒闭~
    weizhen199
        76
    weizhen199  
       2020-12-24 08:48:04 +08:00
    一万行的 SP 看过,一句写了三百行的还蛮勇的
    polymerdg
        77
    polymerdg  
       2020-12-24 08:57:32 +08:00
    才几百行,这里 1000 行以上的 多得很
    cnzjl
        78
    cnzjl  
       2020-12-24 09:00:28 +08:00
    挺正常的
    murmur
        79
    murmur  
       2020-12-24 09:01:06 +08:00
    直观感觉还行,格式良好,命名工整,就是看不懂高端 SQL
    另外,我真听过 SQL 写业务的(存储过程),美其名曰直接热更不需要重启,我竟然无话可说
    chengz
        80
    chengz  
       2020-12-24 09:07:18 +08:00
    其实还好,缩进正常的还是很好看的
    只是新的互联网应用这种查询可能比较少见
    x66
        81
    x66  
       2020-12-24 09:08:10 +08:00
    ERP 报表开发者的日常,这也就一般难度的 sql 吧
    MoccaCafe
        82
    MoccaCafe  
       2020-12-24 09:10:52 +08:00 via iPhone
    这个还行吧,起码没有各种存储过程和未知名的临时表,基本看得懂。 如果联表过于复杂,得考虑是否设计欠佳,业务跟不上
    ZinWUT
        83
    ZinWUT  
       2020-12-24 09:26:02 +08:00
    ERP 业务的日常,hhh
    tianhei826
        84
    tianhei826  
       2020-12-24 09:26:25 +08:00
    写个 MERGE 那么难吗。。。。。
    c6h6benzene
        85
    c6h6benzene  
       2020-12-24 09:27:31 +08:00 via iPhone
    300 行,这才刚开始写吧。除了 Select *之外好像也没啥好吐槽的了。
    jorneyr
        86
    jorneyr  
       2020-12-24 09:30:31 +08:00
    这是人才,得好好保护
    Nicoco
        87
    Nicoco  
       2020-12-24 09:32:35 +08:00
    感觉,再搞搞,是不是会崩溃
    Achiii
        88
    Achiii  
       2020-12-24 09:48:15 +08:00
    数仓抽数的 sql 都很长
    junwind
        89
    junwind  
       2020-12-24 10:03:51 +08:00
    虽然不建议这么做,但是写得出来这样的 sql,也是牛啊
    kimqcn
        90
    kimqcn  
       2020-12-24 10:15:53 +08:00
    交给最新的量子霸权计算机处理看看
    neptuno
        91
    neptuno  
       2020-12-24 10:21:16 +08:00
    楼上各位都不审题吗,,这是用户行为可以随意触发的,,,肯定不能这样写呀
    ojbkojbk
        92
    ojbkojbk  
       2020-12-24 10:23:38 +08:00
    正常操作 之前写报表比这还骚
    solaya
        93
    solaya  
       2020-12-24 10:25:49 +08:00
    这个 SQL 写的不错
    onice
        94
    onice  
       2020-12-24 10:31:44 +08:00
    看能算你输,所以我没看懂,你赢了。这一坨写的真好,我都看不懂。
    jitongxi
        95
    jitongxi  
       2020-12-24 12:07:45 +08:00
    五千行的存储过程都见过, 这算啥
    Frank9621
        96
    Frank9621  
       2020-12-24 13:24:59 +08:00
    兄弟,你这样直接把 sql 贴出来不好吧
    funbox
        97
    funbox  
    OP
       2020-12-24 16:54:06 +08:00
    @Frank9621 有些字段 表前缀已经替换~~
    yanue
        98
    yanue  
       2020-12-24 17:01:40 +08:00
    这不是应该算一行吗
    clf
        99
    clf  
       2020-12-24 17:39:14 +08:00
    估计是可视化的 SQL 查询构造器构造的。
    runninghipp
        100
    runninghipp  
       2020-12-24 18:42:32 +08:00
    这个是报表数据把
    1  2  
    ? ?
    关于   ·   帮助文档   ·   博客   ·   API   ·   FAQ   ·   我们的愿景   ·   实用小工具   ·   1025 人在线   最高记录 6543   ·     Select Language
    创意工作者们的社区
    World is powered by solitude
    VERSION: 3.9.8.5 · 35ms · UTC 23:40 · PVG 07:40 · LAX 16:40 · JFK 19:40
    Developed with CodeLauncher
    ? Do have faith in what you're doing.


    http://www.vxiaotou.com