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

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 慢日志里面搜出来的
业务是前端界面用户可以任意点击。。。。

product_id

Inventory

tenant_id

join

109 条回复 • 2020-12-25 16:51:06 +08:00

1 2

❮

❯

ttys001

2020-12-23 14:23:42 +08:00

sql 不用维护吧，不用吧，不用吧……

funbox

2020-12-23 14:24:33 +08:00

@ttys001 最近优化碰到的，生产环境！！！

hack2012

2020-12-23 14:24:47 +08:00

这个估计是 dba 写的。

totoro52

2020-12-23 14:25:51 +08:00

........写这种 SQL 的也是人才好家伙直接在 sql 里写业务逻辑

ben1024

2020-12-23 14:26:32 +08:00

emm... 能说正常操作吗，在处理数据聚合时根本不知道会写多长的 SQL

melvin

2020-12-23 14:27:18 +08:00

真特么人才几秒输出结果

cslive

2020-12-23 14:27:51 +08:00

见多了，都是从数仓抽数的

kiracyan

2020-12-23 14:28:34 +08:00

虽然是屎山但是整理好应该能看懂的

learningman

2020-12-23 14:31:55 +08:00

不错了，都是英文，结合业务看看就懂
如果把以上都换成拼音首字母，你直接跳楼更干脆些

lovecy

2020-12-23 14:35:27 +08:00

其实结构还挺简单的，LEFT JOIN 一堆表，然后从生成的临时表用 WHERE 抽数，看是能看懂，改起来就痛苦了，最好祈祷不要出问题。。。

czzt1

2020-12-23 14:36:47 +08:00

这才几行，几千行的存储过程写的业务逻辑见过么

acr0ss

2020-12-23 14:37:03 +08:00

结构清晰的，但是理解逻辑就难了。
好在每个 join structure 的 table alias 起名挺用心，意义很明确；在没有注释的情况下，能给出不少提示。

securityCoding

2020-12-23 14:37:28 +08:00

@melvin 应该是在数仓跑的

joesonw

2020-12-23 14:41:05 +08:00

BI 里面不都这么写的吗? 还是这个是业务环境

funbox

2020-12-23 14:42:54 +08:00

@cslive 主要是用户前端点击列表的 sql 。。。。。

tojonozomilk

2020-12-23 14:46:45 +08:00

什么？居然有这么简单的 SQL ？——来自数仓开发

huobazi

2020-12-23 14:48:31 +08:00

几千行的 sp，sp 套 sp，各种传参传 xml 和 json，还不是一个字 ”整“

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

好的代码都是 helloword，但 helloword 不值钱

lllllIIIlll

2020-12-23 14:51:40 +08:00

数据分析那边几百行的 sql 太多了

taogen

2020-12-23 15:29:26 +08:00

某列表页面 SQL，join 20 个，卒

w292614191

2020-12-23 15:30:15 +08:00

你这个一般般，我们这 C#项目，几百行几百行是基本写法。

hafuhafu

2020-12-23 15:33:17 +08:00

其实还好，我们这里抽取报表数据蛮多很长的。

FlyingShark

2020-12-23 15:48:49 +08:00

这个还好，结构还算清楚、而且别名 alias 容易阅读。也见过 700 行的 SQL，一堆 union all 拼起来……

roundgis

2020-12-23 15:56:00 +08:00 via Android

@czzt1 前東家的系統是兩層架構，客戶端直連數據庫，核心代碼就是那堆存儲過程，隨便一個函數都過萬行代碼

fhsan

2020-12-23 15:59:44 +08:00

@roundgis 好家伙，台湾公司有钱买了两份 oracle，同步数据、处理数据等等都是 sql 干，要不买了干嘛

andyskaura

2020-12-23 16:12:17 +08:00

我们整个项目就是这么开发的这样的确不好但是要改吧快 20 年都这么过来了没必要

manami

2020-12-23 16:17:00 +08:00

你是没见过上千行的一个存储过程

fanfpy

2020-12-23 16:47:14 +08:00

存储过程不都这长度吗

fanfpy

2020-12-23 16:47:32 +08:00

![1073bfd22008d0b5439b890c3ca1755.png]( https://i.loli.net/2020/12/23/XL9ERHbihIT6sAB.png)

526326991

2020-12-23 16:54:50 +08:00

做过数据报表表示正常操作~~~

fish267

2020-12-23 16:59:39 +08:00

这种贴数仓代码，不是违规么，要有程序员基本素养哈

thtznet

2020-12-23 17:04:24 +08:00

楼主少见多怪，这段 sql 脚本不是 erp 日常么？楼主估计没有从事过企业内信息系统的开发。

251243021

2020-12-23 17:04:52 +08:00

请问这么多行都是怎么读懂且保证修改不出问题的呢

todd7zhang

2020-12-23 17:08:02 +08:00

ERP 里面满天飞

antiquezzz

2020-12-23 17:08:28 +08:00

看着还是挺整齐的，sql 写的挺好的，这样效率高

xpresslink

2020-12-23 17:10:16 +08:00

其实这东西难度没多大，只是需要充分理解业务和数据的含义。
这种东西就象垃圾堆经年累月堆得太高了以后，让人有一触即溃的感觉而已。

annielong

2020-12-23 17:11:49 +08:00

erp 业务类基本操作，只有 cms 类的不怎么用这些

g76

2020-12-23 17:11:56 +08:00

长见识了

potatoyam

2020-12-23 17:19:10 +08:00

好熟悉看着像理财业务的统计 sql

a54552239

2020-12-23 17:21:41 +08:00

数据量大了，不会卡吗

lcdxiangzi

2020-12-23 17:22:39 +08:00

如果去掉最后一行，会有什么效果？

iRiven

2020-12-23 17:25:03 +08:00

嵌套多层，可以用 with as 把水平代码拆分成垂直，更好理解。

lap510200

2020-12-23 17:35:35 +08:00

联了很多张表嵌套子查询临时表效率低下但是写的人也蛮苦了至少根据理清业务逻辑写出来这些 sql 加上调试这打断 sql 是否满足需求这些所花费的时间估计至少 1 天

除此之外把技术总监拖出去毙了居然没有代码审核

sampeng

2020-12-23 17:42:37 +08:00

才 300 行。。见过几千行的么？弟弟。。。

kisshere

2020-12-23 17:42:55 +08:00

MySQL：你是不是觉得你很幽默？

KaynW

2020-12-23 17:43:42 +08:00

我只看到了 27358

quan01994

2020-12-23 17:54:39 +08:00

还好啦

IrisFrankie

2020-12-23 17:57:12 +08:00

挺整齐的，命名也没啥问题。你理解需求后再读应该会挺简单的。。。不要试图否定它，除非你能优化它

unicloud

2020-12-23 18:00:03 +08:00

打扰了。。。

DarkCat123

2020-12-23 18:04:06 +08:00

这是人类文明的精华。

OldHu

2020-12-23 18:21:34 +08:00

见过 sql 保存成文本文件有 2MB 的吗？你们啊，too naive ！

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

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

v2ex 大部分都是互联网从业者为主，还有很多朋友是前端，所以对这样有点 old style 的东西很陌生，陌生了又容易导致反感。

limuyan44

2020-12-23 18:25:13 +08:00

才 300 行而已，刚毕业那会写了半年 sql,300 行算是起步了。

la2la

2020-12-23 18:25:17 +08:00

@OldHu 对的，oracle erp 系统，包括之前的一些报表系统，300 行基本操作

Vegetable

2020-12-23 18:27:23 +08:00

这个虽然长，但是逻辑不复杂吧，只是字段多而已。

mengdodo

2020-12-23 18:29:22 +08:00

牛皮

yeqizhang

2020-12-23 18:29:36 +08:00 via Android

感觉 erp 报表常见，反正数仓数据处理的我是见过写很多行的

optional

2020-12-23 18:34:58 +08:00 via iPhone

不说 erp，搞数据分析也觉得这个没什么啊

Mohanson

2020-12-23 18:40:41 +08:00

哈哈, 楼主本来想带节奏, 结果楼下一堆人才把楼主描述成一个"没见识的"...

liuxey

2020-12-23 18:54:50 +08:00

PL/SQL：行数算什么，调用栈堪比 Java

mamahaha

2020-12-23 18:56:00 +08:00

这是不想让人抢饭碗吧？升级业务老老实实还得找他。

Umenezumi

2020-12-23 21:49:31 +08:00

数据分析那边儿经常是这种 SQL 啊，这个还算逻辑清晰了

jasonkayzk

2020-12-23 22:07:59 +08:00

想知道这种 SQL 的性能如何= =

Felldeadbird

2020-12-23 22:24:56 +08:00

这 SQL 写得很好啊。至少说明 DB 命名上规范。如果楼主遇到过一推 AS a, b ,c, d...

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

最后，楼主直接贴代码，不怕问责吗？

AntoniotheFuture

2020-12-23 22:26:37 +08:00

小意思啦，我之前一个项目一条 SQL3000 行而且有 4 条，跑一个小时，后来我亚索成 1000 行了，运行时间降到 20 分钟

thetbw

2020-12-23 22:30:28 +08:00 via Android

还好，我们公司 4，5 百行的也有，还是一个 sql 联接 10 多张表的，加上子查询。只能说公司服务器真的强大，还有就是访问量也没有很大，接口速度还能接受

ZhaoHongXuan

2020-12-23 22:36:11 +08:00

odps 上跑的？

uselessVisitor

2020-12-23 22:55:27 +08:00 via Android

@roundgis 青铜器我记得就是这样的好像

kevinjaz

2020-12-23 23:22:08 +08:00

我觉得还好呀

fatestigma

2020-12-23 23:28:04 +08:00

让我想起了当年上数据库课，几个加分题都是这种上百行的，写完之后过一天就看不懂自己写的啥了

FieldFarmer

2020-12-23 23:43:39 +08:00 via Android

很多项目直接把业务逻辑写在 oracle 里面的…用存储过程

Tink

2020-12-24 00:56:28 +08:00 via Android

这不是手写的，这绝壁不是

loading

2020-12-24 01:17:31 +08:00 via Android

看着挺常规

AkideLiu

2020-12-24 01:28:10 +08:00 via iPhone

Oracle : 别难为 MySQL，有啥事冲我来

laicanwen

2020-12-24 08:09:40 +08:00 via Android

我在前公司做 ERP 的时候没有一个存储过程少于 300 行的，而且字段名还是无意义编号，看一个字段查一遍手册。那会要是每个同事写的存储过程能有这样我就谢天谢地了。

Lancerer

2020-12-24 08:32:42 +08:00

这玩意在 mybatis 里的 xml 看才是难受，先把他转成 sql 再说吧。。。

ming7435

2020-12-24 08:42:17 +08:00

我直接就好家伙，这哥们一辈子不会被辞退了，除非公司倒闭~

weizhen199

2020-12-24 08:48:04 +08:00

一万行的 SP 看过，一句写了三百行的还蛮勇的

polymerdg

2020-12-24 08:57:32 +08:00

才几百行，这里 1000 行以上的多得很

cnzjl

2020-12-24 09:00:28 +08:00

挺正常的

murmur

2020-12-24 09:01:06 +08:00

直观感觉还行，格式良好，命名工整，就是看不懂高端 SQL
另外，我真听过 SQL 写业务的（存储过程），美其名曰直接热更不需要重启，我竟然无话可说

chengz

2020-12-24 09:07:18 +08:00

其实还好，缩进正常的还是很好看的
只是新的互联网应用这种查询可能比较少见

x66

2020-12-24 09:08:10 +08:00

ERP 报表开发者的日常，这也就一般难度的 sql 吧

MoccaCafe

2020-12-24 09:10:52 +08:00 via iPhone

这个还行吧，起码没有各种存储过程和未知名的临时表，基本看得懂。如果联表过于复杂，得考虑是否设计欠佳，业务跟不上

ZinWUT

2020-12-24 09:26:02 +08:00

ERP 业务的日常，hhh

tianhei826

2020-12-24 09:26:25 +08:00

写个 MERGE 那么难吗。。。。。

c6h6benzene

2020-12-24 09:27:31 +08:00 via iPhone

300 行，这才刚开始写吧。除了 Select *之外好像也没啥好吐槽的了。

jorneyr

2020-12-24 09:30:31 +08:00

这是人才，得好好保护

Nicoco

2020-12-24 09:32:35 +08:00

感觉，再搞搞，是不是会崩溃

Achiii

2020-12-24 09:48:15 +08:00

数仓抽数的 sql 都很长

junwind

2020-12-24 10:03:51 +08:00

虽然不建议这么做，但是写得出来这样的 sql，也是牛啊

kimqcn

2020-12-24 10:15:53 +08:00

交给最新的量子霸权计算机处理看看

neptuno

2020-12-24 10:21:16 +08:00

楼上各位都不审题吗，，这是用户行为可以随意触发的，，，肯定不能这样写呀

ojbkojbk

2020-12-24 10:23:38 +08:00

正常操作之前写报表比这还骚

solaya

2020-12-24 10:25:49 +08:00

这个 SQL 写的不错

onice

2020-12-24 10:31:44 +08:00

看能算你输，所以我没看懂，你赢了。这一坨写的真好，我都看不懂。

jitongxi

2020-12-24 12:07:45 +08:00

五千行的存储过程都见过，这算啥

Frank9621

2020-12-24 13:24:59 +08:00

兄弟，你这样直接把 sql 贴出来不好吧

funbox

2020-12-24 16:54:06 +08:00

@Frank9621 有些字段表前缀已经替换~~

yanue

2020-12-24 17:01:40 +08:00

这不是应该算一行吗

clf

2020-12-24 17:39:14 +08:00

估计是可视化的 SQL 查询构造器构造的。

100

runninghipp

2020-12-24 18:42:32 +08:00

这个是报表数据把

1 2

❮

❯