1．K3客戶編碼對應關係…………………………………………4
2．船務系統發票……………………………………………….6
3．紗廠系統發票/CNS…………………………………………23
4．船務系統取消單………………………………………………36
5．紗廠系統取消單………………………………………………39
6．dn……………………………………………………………..43
7．cdn……………………………………………………………51
8．剔除無效數據……………………………………………….53.
9．Invoice_summary………………………………………………54.
10．Invoice_summary2…………………………………………….56
11．hk2py………………………………………………………….58
12．對比兩部份數據……………………………………………59.
13．數據更新：new…………………………………………….62
14．數據更新：updated………………………………………….63
15．數據更新：deleted…………………………………………65
16．修改導入狀態：IMPORT_STATUS…………………………66
17．paytype……………………………………………………….68
18．emp…………………………………………………………72
19．從K3導入客戶資料…………………………………………75
20．從k3導入供應商資料…………………………………….81
21．Invoice_merge_sum…………………………………………82
22．Py2hk_deleted_sum……………………………………….84
23．Py2hk_new_sum…………………………………………….84
24．ar_xls………………………………………………………84
25．ar_xls_2……………………………………………………87
26．ar_invoice_out……………………………………………….88
为了理解方便，现在我参照AR中的图形，通过仔细写下分析过程，并不再截图的方式来发现规律，记录细节！随时间用的越多，我就越发现，开始觉得复杂的事物，通过慢慢的观察，静静的思考，然后我会找出各个部分之间的联系，开始时，我现在，不写以前了解到的那些总体上的轮廓，因为，我需要有更深的认识，更细更深的记录！
为了分析方便，现在我仅仅通过语言的方式，来把我对图形的理解一点一点,慢慢的,记录下来，希望,我通过这些分析之后，我不但,对这里面的每一个细节有全面的理解，也希望,在此之后，会在自己的工作之后，在脑海中留下，这每一个细节的记忆，我相信，这一轮之后，我不仅会记住，这个财务监督系统，到底获取了那些部门的数据，这些数据都存放在了那些数据库中，在大量的数据中，系统又需要了谁，而最后淘汰了谁，所以我会记住，这里面最终需要的会是那些表，那些字段，我也会记住，这些字段在这过程中，经过了怎样的名字变换和取值变换，而我也要进一步熟练操作这些，要达到相同的目标，我相信，我一定有更好的方法，在设计世界里，有个设计原则叫“高耦合，低内聚”，这样如果应需求，要修改的时候，这样可以涉及到的表，涉及到的数据库最少，修改也更加方便，因为里面的内容相互之间独立性能好，就如修改某一个字段的时候，以至于懂数据库的人就会修改，我也相信，一定有更好的方法来实现这个目标，我相信，经过这一轮，我有方法可以让系统运行得更快，因为涉及的中间表越少的时候，不但分析更加的简洁，修改更加的简洁，运行涉及的连接也大大减少，这样，在完成同样工作量的情况下，走最直接的路，而这种种最后，节省了运行时间和操作成本！
我要知道，在此之前，也得先熟悉这些环境，我知道，它这过程里，从分别以K3_HK,2.3,ds_erp为连接名的AIS20040902164905, AIS20041216164951，kamhing,ds_erp这四个数据库中选取了数据，所以这四个数据库是数据来源，是这一切分析的对象，我也要知道，有一个以2.252为连接名的dw2005数据库，这是系统运行过程中存放那些临时数据的地方，这里面有几个我们创建的新表，这几个表名千万要记住，因为等下我追着整个工作流程跑的时候，我不会因为不认识路而迷茫，接而迷失方向，还有一个以AR为连接名的AR 数据库，它存放最终的数据，这里也有新建的表，这个我相信自己肯定不会忘记，因为它在大家寄给我的邮件中，不止一次的见过，这表将前面的所有的数据库里面所有表里面所有值得获取的字段都存放到了自己的怀里，所以，当我需要我想要的内容的时候，我可以直接在这个最终的表中查找，这样比在前面那四个数据库中查找那些我们不知道字段存放在何处的数据，要来的方便的多！
现在，我要一边看着AR，一边分析，记录看到的，没看到的！
Select substring(t.fnumber, 1,1)+substring(t.fnumber, 4,1)+ substring(t.fnumber, 6,4) as abbr, t.fnumber
from AIS20040902164905.dbo.t_organization t
left join AIS20040902164905.dbo.t_settle o
on t.FsetID=o.FitemID
left join AIS20040902164905.dbo.t_submessage v
on t.FRegionID=v.FInterID
union Select
substring(t2.fnumber, 3,2)+ substring(t2.fnumber, 6,4) as abbr, t2.fnumber from AIS20041216164951.dbo.t_organization t2
left join AIS20041216164951.dbo.t_settle o2
on t2.FsetID=o2.FitemID
left join AIS20041216164951.dbo.t_submessage v2
on t2.FRegionID=v2.FInterID
看到，substring,它是一个函数，顾名思义，是取字符串类型的某一部分的意思，如substring(t.fnumber, 1,1)，就是取fnumber这个字段值中的第1个字符，而第一句话，Select substring(t.fnumber, 1,1)+substring(t.fnumber, 4,1)+ substring(t.fnumber, 6,4) as abbr,，就是抽取fnumber这字段值中的第一个字符加上第4个字符和第6，第7，第8，第9共6个字符组成的新的字符串，并把这个字段换成新的名字为abbr，这个非常有意义，因为我们后面还可以看到它，而如from AIS20040902164905.dbo.t_organization t
left join AIS20040902164905.dbo.t_settle o
则是从t_organization和t_settle这两个并用左外连接的方式选取数据，left join就是左外连接,意思就是选左表中所有的字段并上右表中有和左表相同的字段的所有值，如果右表中有左表中没有的字段，那么就不选取，如果要选取两个表中不论有相同字段还是没有相同字段，那就用full outer join,如果选择两个中共有的字段，那么就用full inner join,
还有一个是right join,它和left join相反，所以只要表名位置调换，就可以了，所以用得少，再看下，union,相当于数学里面的并集，就是第一段的查询结果并上第二段的查询结果,而且会把相同的记录去除，还有个union all,这样的结果是不会去除重复的行，第一个段的查询结果和第二个段的查询结果记录之和就一定等于union all之后的记录总和，我在接下来的分析之前，要对这一段的内容，有非常充分的理解和掌握，因为我预料到，在后面的transform中，抽取数据库多个表中字段的时候，这个一定要用到，而我也相信，在我充分熟悉之后，我就能非常快的发现其中那些是用错啦，那些没用错！理解这些之后，我开始，总结一下这个表输入总的都做了什么：第一，它把AIS20040902164905中的fnumber字段，取第1,4,6789位组成的取值为第一个新值，把AIS20041216164951中的fnumber字段取第3,6789位组成的取值为第二个新值，而都把结果放在把fnumber字段改名之后的abbr字段中;第二，他也把从两个数据库原来的fnumber放入到了数据流里，这就是这个表输入完成的所有任务。下面，我看表输出，
更简单的是，表输出，第一次创建新表，将新表命名为ar_customer_mapping，
并将其存放在以2.252为连接的数据库dw2005中，我一定要记住这个表，不只因为这个，是第一个transfrom里面的第一个新建的表，更因为，这个表它本身还会被多次使用到，所以珍惜这第一个transform所做的珍贵的成果，它会我后面的分析非常有用！
打开它，可以发现，它比前面我看到的那个要复杂很多，还记得，第一个transform,只有两个entry,而这个居然有13个之多，我按照数据流方向，从第一个，表输入开始研究，打开它，这是来之以2.3为连接的数据库，我看到好多好多的SQL代码，不过别急，慢慢来，看他人的劳动成果的时候，总是需要特多的耐心，所以，我分段来分析它，看到第一段如下
SELECT invoice_no AS INVOICE_NO, Customer AS abbr, invoice_amt AS INVOICE_AMOUNT, due_date AS INVOICE_DUEDATE,
currency AS INVOICE_CURRENCY, desc_eng AS INVOICE_PAYMENTTERM, cp_dept AS INVOICE_DEPT, hk_data AS INVOICE_DATE, Substitute,
buyer_name_eng AS BUYER, label AS LABEL, division AS DIVISION, season AS SEASON, Shipment_Date AS REQ_DATE, Merch_Incharge AS CUSTOMER_MR,
garment_no AS GARMENT_NO, Style_No AS STYLE_NO, Sales_by AS SALES_BY, cp_quyu AS REGION, fabric_name AS FABRIC_NAME, color_name AS COLOR_NAME,
unit_price AS VATNO_DJ, Cust_PO AS PO, Mo_No AS MO_NO, Inland_By AS MR, Pieces AS QTY2, cp_unit2 AS QTY2_UNIT, quantity AS QUANTITY,
quantity_unit AS QUANTITY_UNIT, payment_qty AS PAYMENT_QTY, cp_focqty AS FOC_QTY, unit_code AS UNIT_DJ, cp_focamt AS FOC_AMT,
commission AS COMMISSION, discount AS DISCOUNT, Destination AS PORT_NAME, po_type AS SAMPLE_TYPE, pi_price AS PI_PRICE,
pi_unit AS PI_PRICE_CURRENCY, pi_qty AS PI_QTY, pi_qty_unit AS PI_QTY_UNIT
FROM (
我们姑且先不看FROM后面的表名到底是什么，这里提供给我们的是一大把一大把的字段，从邮件中我了解过，这些字段都是经常看到的那些，尤其是我刚在前面看到的那个abbr字段,在这边是直接由customer而换名而来，其他字段也特别值得注意，如erch_Incharge AS CUSTOMER_MR，一样在邮件中刚刚提及，记住他们，这些主要的字段。熟悉了这字段群之后，开始看下面一段
case when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘R’ then ‘ROLLS’
when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘P’ then ‘PACKAGES’
when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘B’ then ‘BAGS’
when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘C’ then ‘CTNS’
when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘E’ then ‘CONE’
when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘A’ then ‘BALES’
when isnull(Shipment_fabric.piece_unit, ‘R’) = ‘S’ then ‘SET’ end as cp_unit2,
我们先分析一下这个isnull函数，isnull(A，replacevalue)=H,其中A可以是任何类型的数据，replacevalue是当表达式结果为存在H时，那么就执行then后面的替换，其实本来这个函数是一般不用等号的，直接用变量代替上面的R就好，不过可能是作者觉得这样更方便，所以用等号的方法。 如isnull(Shipment_fabric.piece_unit, ‘R’) = ‘P’ 完全可以用
isnull(Shipment_fabric.piece_unit, ‘P’)代替，这样就更容易看懂了，
case when then是一个分支语句，在这里是对数据值的分类，如
select (case province when ‘广东省’ then ‘广东’ when ‘江西省’ then ‘江西’ else province end ) as 省份 from student
Ok，end when then end 分析完了，对了，还有最后一个end as cp_unit2,
cp_unit2，很显然这个是字段的名字，就是把原来的piece_unit换成了新名字cp_unit2。这段代码所做的工作就是把他们进行了字段值的重新分类和字段的改名。下面我看下面一段代码：
FROM dbo.Shipment_fabric WITH (nolock) inner JOIN dbo.invoice WITH (nolock) ON dbo.Shipment_fabric.Invoice_no = dbo.invoice.invoice_no
left JOIN dbo.Orders WITH (nolock) ON dbo.Shipment_fabric.order_id = dbo.Orders.Order_ID
left JOIN dbo.Orders_Assortment WITH (nolock) ON dbo.Shipment_fabric.color_id = dbo.Orders_Assortment.Color_ID
substring(dbo.invoice.invoice_no,1,1) in(‘B’,’M’)
UNION ALL
SELECT distinct
dbo.invoice.Invoice_no,
dbo.invoice.customer,
‘色布’ as p_type,
dbo.invoice.charge_amt as invoice_amt,
dbo.invoice.due_date,
dbo.invoice.currency,
大家在写查询时,为了性能,往往会在表后面加一个nolock,或者是with(nolock),其目的就是查询是不锁定表,从而达到提高查询速度的目的。，这里还用到了一个我们在第一transfrom的时候提到的UNION ALL,就是表示留下重复记录行，是对整个记录即行而言的，第二点我要记住的是distinct,就是去除重字段值，是对表中单个地段而言的。
这一段代码的作用就是从这么多的表中选取某些字段的值，接着我看下面的代码：
dbo.orders_fabric.unit_code,
(isnull(case when dbo.shipment.quantity_unit =’LBS’ or isnull(dbo.shipment.quantity_unit,”) = ” then dbo.shipment.quantity
when dbo.shipment.quantity_unit =’YDS’ or dbo.shipment.quantity_unit = ‘BAG’ or dbo.shipment.quantity_unit = ‘BOT’ or dbo.shipment.quantity_unit = ‘BOX’ then dbo.shipment.yard
when dbo.shipment.quantity_unit =’KGS’ then round( dbo.shipment.quantity /2.2046,2)
when dbo.shipment.quantity_unit =’MTS’ then round(dbo.shipment.yard *0.9144,2)
when dbo.shipment.quantity_unit =’PCS’ then dbo.shipment.yard
when dbo.shipment.quantity_unit =’SET’ then dbo.shipment.quantity2
when dbo.shipment.quantity_unit =’DOZ’ then case when isnull(dbo.shipment.quantity2,0)=0 then dbo.shipment.yard /12
else
这段代码的涉及到的逻辑比较深，一开始我看不懂，其实就是在原来when case then end 的基础上加上了多个条件的判断条件执行语句，并没有特别复杂。这里我跳过这段解释，我看完后面的代码，发现所有的语句几乎和前面的格式一样，只不过是换了表和字段而已，现在我来总结一下这整个SQL语句所做工作：
首先可以确定，这个表输入只涉及一个数据库2.3里面的kamhing,涉及的表有
invoice,
payment_term,
buyer_label,
Shipment，
Shipment_fabric,
Shipment_Out_Dtl,
Orders,
Orders_Assortment,
Orders_Assortment_rec,
orders_fabric,
Orders_Fabric_Specs,
Orders_Fabric_Specs_rec,
从这整个SQL编辑区从上至下分析，每一个好长好长的case when
Then else end 语句最终的结果都只是返回一个字段，所以我分析它的时候，可以越过这些非常漫长的判断，这样的话就会简洁得多，只要看完了第二个select至Union all之间的部分，后面的部分语法完全一样，选择的表和字段也一样，只是判断的条件不同，所需的字段值不同，看看下面这段内容
FROM dbo.Shipment WITH (nolock) INNER JOIN dbo.invoice WITH (nolock) ON dbo.Shipment.Invoice_no = dbo.invoice.invoice_no
INNER JOIN dbo.Orders WITH (nolock) ON dbo.Shipment.order_id = dbo.Orders.Order_ID
INNER JOIN dbo.Orders_Assortment_rec WITH (nolock) ON dbo.Shipment.color_id = dbo.Orders_Assortment_rec.Color_ID
INNER JOIN dbo.Orders_Fabric_Specs_rec WITH (nolock) ON dbo.Shipment.fabric_id = dbo.Orders_Fabric_Specs_rec.Fabric_ID AND
dbo.Orders_Assortment_rec.Specs_ID = dbo.Orders_Fabric_Specs_rec.Specs_ID
left Join dbo.buyer_label with(nolock) on dbo.Orders.buyer_code = dbo.buyer_label.buyer_code
left join dbo.orders_fabric with(nolock) on dbo.orders_fabric.fabric_id = dbo.Shipment.fabric_id
left join dbo.payment_term with(nolock) on dbo.orders.pay_term_code = dbo.payment_term.term_code
WHERE SUBSTRING(dbo.invoice.invoice_no, 1, 1) = ‘D’ AND dbo.invoice.invoice_type = ‘C’ and ( shipment.confirm_flag
> 0 )
这样把这么多字段连接在一起之前，需要对这些字段之间原来的联系要有足够的了解，这里涉及到ERP系统生产中，对于我，没有了解过哪些来说，切实有点复杂；所以，首先先记下它，至于那几个表为什么会有这种千丝万缕的联系，后面会明白的。接下来，整体分析一下这所有SQL查询过程中都做什么：第一步，先从刚列出来的那12个表中，对那些有单元划分的字段进行分类，按照相互之间的联系把那些关于货运相关的运费子类的字段筛选出来组成一个新表，其名derivedtbl_1；第二步，在第一步的基础上，从中筛选出最终需要的字段，这就是整个SQL所做的工作。接下来，我需要看另外一个tableinput,打开它，看到同样是以2.3为连接的kamhing数据库数据源，下面的代码
SELECT distinct Shipment_fabric
dbo.Shipment_sample.Invoice_no,
dbo.invoice.customer,
‘色布’ as p_type,
Round(dbo.Shipment_sample.payment_qty * isnull(shipment_sample.vatno_dj,0),2) as invoice_amt,
dbo.invoice.due_date,
dbo.invoice.currency,
dbo.payment_term.desc_eng,
‘船務部’ as cp_dept,
dbo.invoice.hk_data,
dbo.Orders.Substitute,
buyer_label.buyer_name_eng,
buyer_label.label,
buyer_label.division,
dbo.Orders.SEASON,
dbo.Orders.shipment_date,
dbo.Orders.merch_incharge,
dbo.Orders.garment_no,
dbo.Orders.style_no,
dbo.Orders.sales_by,
case when dbo.Orders.groups = ‘CN’ then ‘中國區’
when dbo.Orders.groups = ‘HK’ then ‘香港區’
when dbo.Orders.groups = ‘KR’ then ‘韓國區’
when dbo.Orders.groups in(‘SA’,’SB’,’SC’,’SD’) then ‘新加坡區’ end as cp_quyu,
我看到，这里和刚刚那个表输入不同的是所选择的表对象多了一个，
Shipment_sample表，这里的Shipment_sample就犹如刚刚Shipment_fabric，而判断条件等等几乎相同，通过下面这一段，分析一下所牵涉的表
left JOIN dbo.Orders_Assortment WITH (nolock) ON dbo.Shipment_sample.color_id = dbo.Orders_Assortment.Color_ID
left JOIN dbo.Orders_Fabric_Specs WITH (nolock) ON dbo.Shipment_sample.fabric_id = dbo.Orders_Fabric_Specs.Fabric_ID AND
FROM dbo.Shipment_sample WITH (nolock) inner JOIN dbo.invoice WITH (nolock) ON dbo.Shipment_sample.Invoice_no = dbo.invoice.invoice_no
left JOIN dbo.Orders WITH (nolock) ON dbo.Shipment_sample.order_id = dbo.Orders.Order_ID
dbo.Orders_Assortment.Specs_ID = dbo.Orders_Fabric_Specs.Specs_ID
left Join dbo.buyer_label with(nolock) on dbo.Orders.buyer_code = dbo.buyer_label.buyer_code
left join dbo.orders_fabric with(nolock) on dbo.orders_fabric.fabric_id = dbo.Shipment_sample.fabric_id
left join dbo.payment_term with(nolock) on dbo.orders.pay_term_code = dbo.payment_term.term_code
WHERE ( substring(dbo.invoice.invoice_no,1,1) = ‘A’ ) and (dbo.invoice.invoice_type = ‘C’)
) as adad
上面我画出来的地方，就是这整个表输入涉及到的表，比起刚才的表输入来，这个表输入，因为涉及的表操作没有刚刚那么多，所以少了很多工作量，不过逻辑还是一样的。通过上面这段代码，总结一下这个表输入所做的工作：第一步，从列出来的表中，按照他们之间的关联字段，通过先对那些分类字段的取值进行分类，赋新值，然后再组成一个新表adad,第二步，从这个新表中抽取那些需要的字段，这就是整个表输入完成的任务。看了半天，终于把这两个表输入的内容给看完了，感觉松了一口气，但是我也知道，这里面的部分，最终还是要回头来研究，因为这里涉及到的部分，韵味深长，这是整个数据筛选的最为重要的部分，这里发生了重要而大量的数据变换，而现在我先告一段落，开始分析下一个entry.
在第二个表输入的流前面，看见了Javascript,其实写下记录，是一个非常好的复习和学习的过程，如果遇到了认识的，那就是一个复习和深化的历程，如果是没学过的，那就是重新学习那些，这里面的JavaScript,我的基础还真不是很好，只是曾经我是亲微软的，当初在学C#编程的时候，看到其他人开发的系统和网页有过这些，那时候就接触了它，所以不熟悉，同样，也不陌生，看到下面的这段代码，开始看看它到底做了什么
函数名（参数）
function transCol2ToCol1(col1, col2, num
{
var trimedcol2;
var col2length;
if(col2==null||trim(col2)==” “||trim(col2)==””)
{
if (col1==null||trim(col1)==” “||trim(col1)==””){
return ” “;
} 正则表达式
每行第4个空格替换成换行符
return col1;
}
trimedcol2=trim(col2.replaceAll(“[^\x00-\xff]”,”11″));
col2length=trimedcol2.length;
if(col2length<=num&&col2length!=0){
return col2;
}
else if (col2length>num&&(col1==null||trim(col1)==” “||trim(col1)==””)){
var ch,bytenum=0;
var rs = “”;
var pt = /[^\x00-\xff]/;
for (var i=0; i < num; i++)
{
ch = col2.substr(i, 1);
if (ch.match(pt))
{
bytenum += 2;
if (bytenum > num)
{
return rs;
}
}
else{
bytenum += 1;
}
rs += ch;
if (bytenum == num){
return rs;
}
}
return rs;
}
else{
return col1;
}
MO_NO.setValue(transCol2ToCol1(“”,MO_NO.getString(),30));
看的出来，上面的脚本就是先定义了一个处理的函数，所谓函数，只是翻译成中文是函数，在英文中的本名叫做功能，作用，就是把一个功能封装在一起，加上调用所传递的参数，最后一行，就是调用了这个函数来处理MO_NO这个字段，使那些符合条件的内容变为空值。
这段代码我有些看不懂，因为以前这种编程的循环好像和这个有点不一样，所以有点特别。我想写跳过去，以后再慢慢琢磨。
下面看到append streams,
这可能是这里看到的最简单的一个entry了，它仅仅是把两条数据流中的数据进行汇合在一起，但条件是这两个数据流中的字段必须相同。这样才能汇合。使用操作也非常简单。第一个方框中输入给他取的名字，第二个方框中输入第一个选择的流源，第三个选择第二个数据流来源，这样点击OK就把两边的数据合到一个了，别看它使用起来这么简单，可它的作用是非常大的。从这里，我可以反思一下，刚刚两边的表输入，他们分别获取的字段是完全相同的，而且最后的字段数据类型也一样要分别对应，现在，这里汇合之后，这里成为了整个transform里面的所有数据源，从这里开始，下一步就是数据处理部分了。我接着，打开Database lookup,
先复习一下，这个entry,其实，这里面的每一个entry,都是一个函数的聚合，这里应该这样理解，它就像我们在编程时候写下的函数，当我们需要调用它们的时候，我们就要输入或者选择好参数，函数根据我们提供的参数，再去执行任务，最后返回结果，而Database lookup,其实和表输入一样也是数据源的一种，先谈谈look up的英文意思，它的意思是查找的意思，可以知道，这里就是查找另外一个表中某些字段的值，然后添加到这个流中，因为它也是获取数据源的一种，所以他也和数据库有连接，打开它，我看到，它的数据来源来之2.252为连接的ar_customer_mapping表，我非常深的记得，这个表是在第一个transform的时候创建的，客户编码的那个，仅仅是对fnumber字段的值进行了分类，然后把其中部分换成了新的字段值，这样的而已，所以现在从这里把它用上了，所以当初我说要记住它，现在真的用上了，这这边，这是一个非常需要记住的内容。现在明白，千万别怪作者太罗嗦，其实他把这个系统弄得这么复杂，也是没有办法的，这就好比SQL语言中，我查询数据库里面字段值的时候，当经常涉及到一些复杂查询的时候，就经常要分成多个步骤，在第一个步骤的基础上，再查找，这结果就是第二个步骤的结果，在第二个结果的基础上查找得到结果3，如此循环往复，这样其实本来就是为了简化问题，使问题更符合我们的逻辑，一般人更容易懂，也更不容易出错，但是在数据设计部分，我曾经看过oracle方面的书，那些说提高效率的往往反对使用多重查询，因为这样会降低效率，使效率很低，但是没有办法啊，这里至少现在只能如此。也许我这里说得太多，但是，相信这是一个非常重要的思想，从Kettle的设计当中我想起了SQL语言，因为他们本身就是同体，这上面所说的思想我觉得是我慢慢看，然后体会出来的，这种体会，我想对我会很有帮助的，我相信，我在领会这个的基础上，对我以后去设计从庞大而复杂的数据源中获取数据，再进行清洗和加工，进行编号的时候，这个会有非常大的作用，创建中间表，准备好数据表，就是先设计好的一种构架。很幸运的是，作者并没有把那些获取数据源的步骤的架构图给我，而让我慢慢自己去探索，我探索出来的，是一个还不完整，但是正在完整的过程，它能深入我的大脑中，所以，这段日子里，我要花足够多的思维去领悟剩下的，怀念以前的。
我看到第一个编辑框，The key(s) to look up the value, 这个
故名思义，两个表之间共有的字段，这里把他叫做key,其实在各自的表中，它未必一定就要是主键，就是说这里的key,和数据库中的key是有所不同的，哪里的key不是主键就是外键，而这里我看到，其实慢慢的就能理解，为什么要有两个表中的共有字段呢？因为如果没有共有字段的话，那么添加字段的时候，就没有参照，没有参照多条记录合在一起的时候，就只能按照默认，而那样就很可能导致错乱，所以就一定要有共有字段。而第二个编辑框，诸Values to return from theLook up table,也不难理解，就是查找的那个表中要返回的字段，这里选择了fnumber,其实我还记得，这个表中无外乎abbr和fnumber这两个字段，在这里我才知道，它给他重新字段改名为cust_name其实就是客户名字的意思。好了，这里OK了，我接着看下一部分的内容。打开value mapping,,
先谈一下mapping,因为这个数据库世界里，我要常常和她见面,原词本是map,地图之意也，mapping是一个动词，筹划，映射，地图的意思，所以现在这里应该是映射值，就是把某些字段的值进行映射，如汉子里面的成绩优，良，不及格三等级映射为英文里面的Ａ，Ｂ，Ｃ，所以这样也就容易理解了。
好了，接着下一个entry,select values, 一样，一点也不陌生，即为筛选值，专业点，就是过滤，过滤就是选取那些想要的字段，这里有三个编辑框可供选择，第二个是Remove，当我们在第一个编辑框中把所有字段都选进来了的时候，这个编辑框就其作用了，可以把那些不要的，少部分不要的字段给T掉，所以这也不是多此一举，而是帮我们节省了时间，第三个编辑框，meta data,其中meta是变换之意，其实在第一个编辑框SELECT&ALTER就已经有这第二和第三编辑框的功能了，这里之所以加上重命名字段的部分，是为了更加方便，其实作用是相同的。好了这里看完了，接着看下一部分的内容。Filter rows,
千万别说错啦，其实刚刚我也说过select values这个entry也是筛选功能，select values是针对字段的选取，而这里是针对字段里面值得选取，看到编辑框我知道，这里选取字段为INVOICE_NO进行判断，如果值以A,H,D开头的发票号码，则不需要进入下一环节。到这里，由于上次我觉得其他也一样，所以直接进入下一个entry了。Sort rows,
对行排序，行排序，就是选择好字段之后，按照字段值降序或者升序排序，AS为升序，ＤＳ为降序的意思，后面一个列显示的sensitive compare, 我知道英文意思是敏感对比，因为是敏感对比，我理解是应该是在同样值得情况下，会按照一定的方式编排顺序，这个因为可能容易引起错误。现在到了groub by了，
groub by，毫无疑问，是按照组分类的意思，这个在SQL中我常遇到过，在这里我举一个不带截图的例子：从一个班级中选择所有人的名字，学号，性别和成绩，如果选好字段按性别分组，然后再选择按成绩分组排序，那么先按性别分成两组，一组为男生，一组为女生，在男生那半部分，以男生的成绩排序，在女生那部分，以女生的成绩排序，所以group by 这里也是这样的意义。这里的下面一栏，aggregate,
就是聚合，合计的意思，在这里，是把那些关于数值型的值给聚合，比如分类，求最大值，求最小值，求平均值，方差等等这个值，可以直接放在本字段的末尾，如果放在末尾，那么这里我就要在Subject中选择和前面相同的，如果不这样，可以写一个新的名字，那么这样下来，就创建了一个新的行，来存放这个聚合值。当然我现在的理解即是如此。这一点，在后面我依然需要加强，现在到下一步，
又是javascript，这个JavaScript编辑框中，的上半部分，比起刚刚那个javascript来，可是要来得简单很多，
if (substr(INVOICE_NO,0,1)==’H’)
INVOICE_TYPE=”5101.03.05.02″;
INVOICE_SUBTYPE=”5101.03.05.02″;
if (substr(INVOICE_NO,0,1)==’M’)
INVOICE_TYPE=”5101.03.05.01″;
INVOICE_SUBTYPE=”5101.03.05.01″;
if (substr(INVOICE_NO,0,1)==’A’)
INVOICE_TYPE=”5101.03.05.04″;
INVOICE_SUBTYPE=”5101.03.05.04″;
if (substr(INVOICE_NO,0,1)==’D’)
INVOICE_TYPE=”5101.03.05.02″;
INVOICE_SUBTYPE=”5101.03.05.02″;
我非常清楚的记得，在第一个tarnsfrom的时候，还是在其他地方的时候，曾经都遇到过这样类似的，substr,你懂的, 分部取值的意思。当第一个字母是什么什么的时候，就执行IF括号里面的内容，在第二个编辑框中，新增加的两个字段就是这样作用的。看到本transfrom,达到了最后一个entry,我终于松了一口气，表输出，很是简单的一个部分，这里就是把前面所有做好的数据发送到目标表中，这个表名输入进去，如果这个表名在目标数据库中已经有的话，那就不用再闯几年了， 有个前提，就是这个表中的字段和流中最后的字段必须相同且字符类型也相同，不然就会运行出错，所以一般我们都是写一个原来数据库中不存在的表名，既然不存在，那么现在就要用SQL语言通过kettle去创建这个表，点击ＳＱＬ按钮，然后执行，就可以成功创建一个表。最后运行就能把所有的数据输入那个表中。
到了这里，我看见了那个非常伟大的2.252为连接的import_temp表，这个表在我刚开始分析AR的时候，就深知其重要性。所以记住它。到这里，这个tranform
分析完了。下面我总结一下这整个transfrom所做的工作：
从2.3中抽取的船务信息，进行分类、清洗转换，再加上第1个transform从K3_Hk编好的客户编码系统，最后进过过滤筛选，字段更新操作，最后导入到了2.252的import_temp,所以这里最为重要的部分，就是前面部分，同时这也是在第一个transform的基础之上，才能做的工作。
3.现在开始，我分析第三个transform
打开这个transform,当我刚接触前面部分的时候，感觉是这么的吃力，
因为这里的部分，它总是涉及那么多的代码，涉及那么多的代码，我在第2个transform中，从一开始的眼花缭乱到找出规律，是一个从复杂到简单的过程，所以我已经有了耐心，现在打开它，又一个复杂点的表输入。
在这里，只要我记录到的地方，我都会用画笔把它画出来，因为这样更方便回忆，看前面部分的代码
SELECT
a.invoice_custom_no as ‘INVOICE_NO’,
a.customer as ‘abbr’,
b.fabric as ‘FABRIC_NAME’,
round(b.units * b.fact_quantity, 2) as ‘INVOICE_AMOUNT’,
a.money_type as ‘INVOICE_PAYMENTTERM’,
a.money_date as ‘INVOICE_DUEDATE’,
b.unit_type as ‘INVOICE_CURRENCY’ ,
c.footnote as SALES_BY,
e.sales_notes as REGION,
space(10) as ‘INVOICE_DEPT’,
c.inland_by as ‘MR’,
a.f_date as ‘INVOICE_DATE’,
c.substitute as ‘BUYER’,
space(10) as ‘DILIVERY_DATE’,
c.shipment_date as ‘REQ_DATE’,
c.customer_by as ‘CUSTOMER_MR’,
c.style_no as ‘STYLE_NO’,
a.mo_no as ‘MO_NO’
FROM invoice_custom a with(nolock),
invoice_custom_detail b with(nolock),
orders c with(nolock),
salesman e with(nolock)
这个以ds_erp为数据源和ds_erp为数据库的表输入，比起第二个transform来可是要来得简单很多很多，如果按照union 来划分的话
可以分成6部分，但是中间四部分都是从完全相同的表中抽取相同的字段，只是Where之后的条件判断不同，所以，当初邮件中有分析任务的时候，我一直在看这个，所以就看出来了规律，现在，把中间四个相识的再抽取一个出来
select a.invoice_no as ‘INVOICE_NO’,
a.bill_customer as ‘abbr’,
b.Fabric_Name as ‘FABRIC_NAME’,
round(b.payment_qty * b.price, 2 ) as ‘INVOICE_AMOUNT’,
a.payment as ‘INVOICE_PAYMENTTERM’,
a.due_date as ‘INVOICE_DUEDATE’,
a.currency as ‘INVOICE_CURRENCY’,
c.footnote as SALES_BY,
e.sales_notes as REGION,
space(10) as ‘INVOICE_DEPT’,
c.inland_by as ‘MR’,
a.hk_data as ‘INVOICE_DATE’,
c.substitute as ‘BUYER’,
space(10) as ‘DILIVERY_DATE’,
c.shipment_date as ‘REQ_DATE’,
c.customer_by as ‘CUSTOMER_MR’,
b.style_no as ‘STYLE_NO’,
b.mo_no as ‘MO_NO’
from invoice a with(nolock),
V_Comm_List_Detail b with(nolock),
orders c with(nolock),
salesman e with(nolock)
where a.invoice_id = b.invoice_id
and ( a.invoice_type = ‘C’ or a.invoice_type is null )
and a.c_type=0
and a.cancel_flag = 0
and a.confirm_flag = 2
and b.mo_no = c.mo_no
and c.footnote = e.sales_name
and a.hk_data >=’2011-1-1′
一段并不复杂的关联表查询，和我平时练习的时候看到的，仅仅是多了几个字段而已，连表也不怎么多，而现在需要熟悉的是这些字段
因为这是数据源，这里筛选出来的字段，一定是和目标地点有关系的，有的是需要经过改名、替换清洗等等，正是因为他们会经过各种变换，所以现在需要对他们本来是谁要记住。还有一个是在分析第一个transform的时候，曾经温习过的，union all和union 的区别，因为那天晚上，给我留下非常深刻的印象，下面我再举一个非常好的例子：
请注意，UNION 内部的 SELECT 语句必须拥有相同数量的列。列也必须拥有相似的数据类型。同时，每条 SELECT 语句中的列的顺序必须相同。
SQL UNION 语法
注释：默认地，UNION 操作符选取不同的值。如果允许重复的值，请使用 UNION ALL。
另外，UNION 结果集中的列名总是等于 UNION 中第一个 SELECT 语句中的列名。下面的例子中使用的原始表：Employees_China:
Employees_USA:
使用 UNION 命令列出所有在中国和美国的不同的雇员名：
注释：这个命令无法列出在中国和美国的所有雇员。在上面的例子中，我们有两个名字相同的雇员，他们当中只有一个人被列出来了。UNION 命令只会选取不同的值。
UNION ALL
UNION ALL 命令和 UNION 命令几乎是等效的，不过 UNION ALL 命令会列出所有的值。
使用 UNION ALL 命令实例：列出在中国和美国的所有的雇员：
因为我们这里用的是union all,所以我怀疑它会把那些重复的结果显示出来，这样的话，如果在这个基础上算合计总和的话，就会出错，虽然说后面的判断条件有的不同，但是如果恰好碰到了相同的结果的话，那么重复就出现了，本数据表结果没有任何主键，所以难保证所有的值都不重复，所以最好的方法，是在所有的表中都尽量添加主键，这样出错的概率就小了，查找数据和处理数据都简便得多。
这里开始进入下一个entry,
Database lookup,,由于在前面第2个transform的时候，我已经详细的了解过它的function,作用，所以我这里仅仅需要看着这个图回忆一下即可了，拿出上次那个Database lookup,和这个完全一样，查找的是一样的表ar_customer_mapping,取的是一样的字段，abbr为参照键，还说过，这里的key和数据库中的不完全相同，这里的fnumber也一样。
进入下一个entry, ,Select values,选择字段，当初我还说过，select values和filter rows的区别，前者是针对字段的，
就是选择那些字段，它还有三个编辑框，其中第一个编辑框里面有第二和第三个编辑框中全部的内容，后者是针对字段里面的数据值而言的，当需要它的值得时候，就使用它。 ，这个和我在第2个transform里面看到的也完全一样，下面是
排序，排序也是选取了INVOICE_NO,FAB+RIC_NAME,MO_NO3个字段以升序的方式排序，回忆了分组group by,现在我再用一个例子来回忆SQL中，合计函数 (比如 SUM) 常常需要添加 GROUP BY 语句
SQL GROUP BY 语法：
SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
我拥有下面这个 “Orders” 表：
现在，我们希望查找每个客户的总金额（总订单），
我们想要使用 GROUP BY 语句对客户进行组合。
我们使用下列 SQL 语句：
SELECT Customer,SUM(OrderPrice) FROM Orders
GROUP BY Customer
结果集类似这样：
很棒吧，对不对？
让我看一下如果省略 GROUP BY 会出现什么情况：
SELECT Customer,SUM(OrderPrice) FROM Orders
结果集类似这样：
打开这个transform， 很好吧，也就4个非常简单的transform,这个表输入的数据是来自2.252的import_temp,
SELECT INVOICE_NO, CUST_NAME, INVOICE_DUEDATE, INVOICE_CURRENCY, INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, SALES_BY, REGION
FROM import_temp
WHERE (IMPORT_STATUS >= 0) AND (INVOICE_DATE >= ‘2011-1-1’)
这个也很简洁吧，就从前面的我看过的那些transform中抽取这9个字段的值放入流中，然后以 INVOICE_NO排序和分组 现在分析一下这里了，因为前面并没有在这里进行深入的分析，这个Aggregates到底做什么了呢，这个加入的要求最大值的这些行是怎么取的？取到之后放到了哪里？我想应该会是取字段中的一个聚合，然后放到该字段的最后一条记录上面。现在看到这个表输出了这个是这里新创建的表 ar_import_temp_summary,同样的，这也是一个非常重要的表, 后面的其他transform中一样，我一样会看到它，算起现在，kettle一共创建了那些表呢，应该就是下面三个
ar_custommer_mapping,
import_temp,
ar_import_temp_summary，而且这3个表都是创建在2.252中，也就是说，在这之前还没有和ＡＲ数据库打过交道。
到了这里，第９个transform分析完了，从2.3中抽取船务和发票相关的数据，然后再以发票号排序和分组统计，最后导入数据到新创建的表ar_import_temp_summary中。
10.现在开始，我看第10个transform,
，比起前面的来，够简单吧，看表输入中SQL：
SELECT INVOICE_NO, CUST_NAME, INVOICE_DUEDATE, INVOICE_CURRENCY, INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, SALES_BY, REGION
FROM ar_import_temp_summary
现在是在刚才的基础上，从刚刚新建的那个表中，抽取那些输入的数据，好了看更新
同样的是以INVOICE_NO作为参照字段，将数据流中的数据替换成流中的数据，这样做的目标就是把原来的旧数据全部替换成现在的新数据。这个transform所做的事情，就是把原来的全部的旧数据换成新数据。
11.现在开始，我看第11个transform
打开这个transform, 新朋友ＡＲ终于出现了，表输入中的SQL显示，这些都是从AR中的import_temp中筛选那些数据,在温习一下这些字段吧
SELECT INVOICE_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE, INVOICE_CURRENCY,
INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE, CUSTOMER_MR,
GARMENT_NO, STYLE_NO, SALES_BY, REGION, FABRIC_NAME, VATNO_DJ, PO, MO_NO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT
FROM import_temp
WHERE INVOICE_DATE>= ‘2011-01-01′ AND (REMARKS <>’更新程序清零’ OR REMARKS is null)
从上面的代码中可以看出，这是和清除数据表中原有的数据有关，
下面看到表输出， ，第5个新表出现了，import_temp_ar_hk,千万别把这个和import_temp_summary混淆了。好了，总结一个这个transform所做的工作：
从AR数据库的ar_import_temp中抽取要清除的数据，然后将数据导入到2.252的import_temp-ar_hk中。
12.现在开始，我看第12个transform
打开看出，这里用了两个表输入，打开第一个表输入，看里面的SQL：
SELECT INVOICE_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE, INVOICE_CURRENCY,
INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE, CUSTOMER_MR,
GARMENT_NO, STYLE_NO, SALES_BY, REGION, FABRIC_NAME, VATNO_DJ, PO, MO_NO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT,DN_FLAG
FROM import_temp_ar_hk
再打开第二个表输入，里面的SQL如下：
SELECT INVOICE_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE, INVOICE_CURRENCY,
INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE, CUSTOMER_MR,
GARMENT_NO, STYLE_NO, SALES_BY, REGION, FABRIC_NAME, VATNO_DJ, PO, MO_NO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT ,DN_FLAG
FROM import_temp
WHERE IMPORT_STATUS >=0 and INVOICE_DATE>=’2011-1-1′
我对比着两部分的SQL，不同的地方获取数据源的表，一个是import_temp,一个是import_temp_ar_hk,其中后面这个表是前面的transform创建的，而且当初得到这个表数据条件是
WHERE INVOICE_DATE>= ‘2011-01-01′ AND (REMARKS <>’更新程序清零’ OR REMARKS is null)
现在这两个表的数据又合在了一起，看到后面的部分 顾名思义，操作字符串， 很明显，这里是将字段为INVOICE_NO的小写改成大写，也要去除空格，再看后面部分， ，这部分是整个tranform最为重要的部分，合并 ，merge,如果有非常好的直觉，就可以体悟到，merge有点像有人的创伤，慢慢愈合这种感觉，在医学上，这种愈合，最好是自己的肉，因为它有共同的性质，这样相似的地方多，然后经过这些相同的性质的地方，然后再慢慢的长肉，所以这里也是这么一个意思，很相像的，左边的是两个表中都有的字段，后面的部分是需要合并的地方。这种合并不是字段的合并，而是满足左边三个字段相同的情况下，对于的将值合并，在前面分析其他工具的时候，我已经说过，有针对表的，有针对字段的，有针对值的，而这里，也是针对值的一种，好了，看最后一个部分，表输出， ar_merge, 这个表在前面并没有出现过，是这里创建的，我前面还说过，AR中，ds_erp,2.3和k3_hk中所有的表都是原来有的，并没有在这里创建，而2.252和AR中所有的表都是由AR创建的。记住这个ar_merge吧，相当重要。好了，这个transform是将import_temp中的数据和import_temp_hk合并之后输入新创建的表ar_merge中。
13.现在开始，我看第13个transform
打开这个transform. ,里面也仅有一个表输入和一个表输出，看表输入里面的SQL代码：
SELECT INVOICE_NO, FABRIC_NAME, MO_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE,
INVOICE_CURRENCY, INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE,
CUSTOMER_MR, GARMENT_NO, STYLE_NO, SALES_BY, REGION, VATNO_DJ, PO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT,DN_FLAG
FROM ar_merge
WHERE (flagfield = ‘new’)
这是来自2.252为连接的ar_merge里面的数据，这个表是前面那个创建好了的，所以，可以看出，这些transform都是前后之间是要很严密的逻辑顺序的，选取数据的条件是flagfield的值为new,表输出中，是将这些数据输入AR中的import_temp.好了，这个transform分析完了 14.现在开始，我看第14个transform
打开这个transform, ,看到表输入中的SQL
SELECT INVOICE_NO, FABRIC_NAME, MO_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE,
INVOICE_CURRENCY, INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE,
CUSTOMER_MR, GARMENT_NO, STYLE_NO, SALES_BY, REGION, VATNO_DJ, PO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT,DN_FLAG
FROM ar_merge
WHERE (flagfield = ‘changed’)
和上一步几乎差不多， 从这里能看出，这步骤是更新AR数据库中import_temp表的数据，这里重复一下inert/update这个工具里面的内容， 这里的三个字段是更新数据库中数据时候的参照字段，和SQL语句里面的两个表直接的等值连接一样如select c1 from t1,c2 from t2 where t1.c1=t2.c2
而上面部分的三个字段就相当于这里where后面的部分，好了，这个tranform分析完了。
15.现在开始,我看第15个transform
打开这个transform,这里的第一个表输入和前面的完全相同，代码如下
SELECT INVOICE_NO, FABRIC_NAME, MO_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE,
INVOICE_CURRENCY, INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE,
CUSTOMER_MR, GARMENT_NO, STYLE_NO, SALES_BY, REGION, VATNO_DJ, PO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT
FROM ar_merge
WHERE (flagfield = ‘deleted’)
表输出也完全相同，仅仅是多了一个js, 这个 就是和前面的transform不同的地方，是彻底的把这些数据给删除。最后一步的表输入，当然毫无疑问是把空的数据输入到了AR 中的import_temp了。现在分析完了这个tranform,回顾一下这前面3个tranform所做的全部工作：
第一， 将新数据输入AR表，第二，将旧的数据更新，第三，将原来的数据删除。
16.现在开始，我看第16个transform
可以预见，16这个tranform将会特别简单， ，看到表输入里面的内容，现在仔细分析一下
SELECT newentry.INVOICE_NO, CASE WHEN existingentry.INVOICE_NO IS NULL THEN 0 ELSE 2 END AS IMPORT_STATUS
FROM (SELECT INVOICE_NO
FROM import_temp_ar_hk
GROUP BY INVOICE_NO) AS existingentry FULL OUTER JOIN
(SELECT INVOICE_NO
FROM ar_merge
WHERE (flagfield = ‘new’)
GROUP BY INVOICE_NO) AS newentry ON existingentry.INVOICE_NO = newentry.INVOICE_NO
WHERE (NOT (newentry.INVOICE_NO IS NULL))
UNION
SELECT INVOICE_NO, 2 as IMPORT_STATUS
FROM ar_merge
WHERE (flagfield = ‘changed’) OR
(flagfield = ‘deleted’)
GROUP BY INVOICE_NO
虽然这个表输入中的SQL语句很短，但是这段ＳＱＬ语句极具代表性，因为它涉及到前面讨论过的很多语法问题，这里仅仅是用了两个数据表，一个是import_temp_ar_hk,还有一个是ar_merge，
涉及到的语法有，outer join,union,case when then end as, groub by等。
现在，来讨论这段SQL语句里面的逻辑结构，首先，从Import_temp和ar_merge中筛选INVOICE_NO字段的数据，组成的新表分别命名为别名exitstingentry和newentry,,再将其所拥有的数据值抽取出来，去除空值，然后，从ar_merger中将所有INVOICE_NO的值抽取出来，组成新的数据表，最后从这个数据表中抽取INVOICE_NO，如果这个INVOICE_NO为空值，则将其导入状态值设为0，如果不为空值，将其导入状态设为2。下面看， ，无需怀疑，这里就涉及前面两个字段，将AR 中import_temp的导入状态更改。
17.现在开始，我看第17个transform
好不容易弄好了，不知道按了那个键，突然卡住了，晕死，现在这个transform又要重新开始写了。这个transform里面有两个表输入，一个为从K3_HK中抽取一个字段PaymentTerm，一个为从AR中的pary_type表中抽取字段。现在看SELECT MAX(CONVERT(int, substring(Paytypeid,4,5))) AS Expr1
FROM paytype这个是第一个表输入中的代码，这里是选取这个列中的最大值，第4未开始的5个数。看下面的第二个表输入中的代码
select distinct PaymentTerm,? as ser from(
Select
substring(t.fnumber, 1,1)+substring(t.fnumber, 4,1)+ substring(t.fnumber, 6,4) as abbr,LTRIM(RTRIM(t.FName)) as CustName,LTRIM(RTRIM(t.FAddress)) as FAddress,LTRIM(RTRIM(t.FPhone)) as FPhone,LTRIM(RTRIM(t.Ffax))as Ffax,
LTRIM(RTRIM(o.FName)) as Fname1,LTRIM(RTRIM(t.FContact)) as FContact,LTRIM(RTRIM(v.FName)) as Fname2,LTRIM(RTRIM(t.FShortName)) as FShortName,t.fnumber
,substring(t.fnumber, 1,4) as CityID,t.Fcorperate, o.FName AS PaymentTerm, e.FName AS EmpName
from AIS20040902164905.dbo.t_organization t
left join
AIS20040902164905.dbo.t_Emp e ON t.Femployee = e.FItemID LEFT OUTER JOIN
AIS20040902164905.dbo.t_settle o
on t.FsetID=o.FitemID
left join AIS20040902164905.dbo.t_submessage v
on t.FRegionID=v.FInterID
where t.FNumber like ‘B%’
union
Select
substring(t2.fnumber, 3,2)+ substring(t2.fnumber, 6,4) as abbr,LTRIM(RTRIM(t2.FName)) as CustName,LTRIM(RTRIM(t2.FAddress)) as FAddress,LTRIM(RTRIM(t2.FPhone)) as FPhone,LTRIM(RTRIM(t2.Ffax))as Ffax,
LTRIM(RTRIM(o2.FName)) as Fname1,LTRIM(RTRIM(t2.FContact)) as FContact,LTRIM(RTRIM(v2.FName)) as Fname2,LTRIM(RTRIM(t2.FShortName)) as FShortName,t2.fnumber
,substring(t2.fnumber, 1,4) as CityID,t2.Fcorperate, o2.FName AS PaymentTerm, e2.FName AS EmpName
from AIS20041216164951.dbo.t_organization t2
left join
AIS20041216164951.dbo.t_Emp e2 ON t2.Femployee = e2.FItemID LEFT OUTER JOIN
AIS20041216164951.dbo.t_settle o2
on t2.FsetID=o2.FitemID
left join AIS20041216164951.dbo.t_submessage v2
on t2.FRegionID=v2.FInterID
where t2.FNumber like ‘C%’) as emp where EmpName<>” and EmpName is not null
当分析ＳＱＬ代码的时候，按照这种分层的方法，可能会更好些，这里可谓是同时涉及到多个数据库多个表的查询。不过，最终查出的字段就是PaymentTerm，现在，开始进入下一步 ，这个太熟悉不过了，看里面查询的是ＡＲ中的pay_type表中的paytype_id 并将其重新命名为id
现在看下一步， ，AR中第一次使用序列，序列是什么呢？就有点像是数据库中的等差数列，就是增加了一个字段，这字段的值是随着记录的增多，自动增长的，至于作用，到了后面用到这个id的时候，再分解。后面 ，是用来计算的工具，计算的内容，
就是把前面的ser字段+前面序列生成的valuename，然后变成新的字段sequence为名的新字段。看到接下来的 ，添加字段，里面是 这里是把sequence<10的时候，将新添加的字段zerop值设为0.后面的 select values筛选的是sequence字段， 这是第二个 ，里面是
这里的PM-是一个字符串，这里的zerop是上次添加的字段，这里的意思是添加一个新字段Paytypeid，其值为PM-这个字符串加上zerop这个字符串加上sequence这个字符串的结果。最后看到
插入更新数据库， 是参照字段，需要更新的字段是 paytype，
和paytypeid，分别更新成为流中的paymentTerm和paytypeid中的值，再次申明，这里是针对字段值而非字段而言的，所以是更新的值。
好了这个tranform分析完了，下面总体分析一下这个tranform所做的工作：
通过查询AR的pay_type及其K3_HK的两个数据库中的多个表所得到的两个字段paytype和paymenTerm两个字段，再更新AR中的paytype表中的相应字段。
18.现在开始，我看第18个transform
打开这个emp,如图所示，和刚才的一模一样的结构
在这里，按照上面的编号，1的表输入是从AR中的personnel中抽取personnelID，而前面那个transform是从paytype中抽取pertype_id,所以是换汤不换药
SELECT MAX(CONVERT(int, PersonnelID)) AS Expr1
FROM Personnel
而后面的这个表输入，也仅仅是换了名字
select distinct EmpName,? as ser from(
Select
substring(t.fnumber, 1,1)+substring(t.fnumber, 4,1)+ substring(t.fnumber, 6,4) as abbr,LTRIM(RTRIM(t.FName)) as CustName,LTRIM(RTRIM(t.FAddress)) as FAddress,LTRIM(RTRIM(t.FPhone)) as FPhone,LTRIM(RTRIM(t.Ffax))as Ffax,
LTRIM(RTRIM(o.FName)) as Fname1,LTRIM(RTRIM(t.FContact)) as FContact,LTRIM(RTRIM(v.FName)) as Fname2,LTRIM(RTRIM(t.FShortName)) as FShortName,t.fnumber
,substring(t.fnumber, 1,4) as CityID,t.Fcorperate, o.FName AS PaymentTerm, e.FName AS EmpName
from AIS20040902164905.dbo.t_organization t
left join
AIS20040902164905.dbo.t_Emp e ON t.Femployee = e.FItemID LEFT OUTER JOIN
AIS20040902164905.dbo.t_settle o
on t.FsetID=o.FitemID
left join AIS20040902164905.dbo.t_submessage v
on t.FRegionID=v.FInterID
where t.FNumber like ‘B%’
union
Select
substring(t2.fnumber, 3,2)+ substring(t2.fnumber, 6,4) as abbr,LTRIM(RTRIM(t2.FName)) as CustName,LTRIM(RTRIM(t2.FAddress)) as FAddress,LTRIM(RTRIM(t2.FPhone)) as FPhone,LTRIM(RTRIM(t2.Ffax))as Ffax,
LTRIM(RTRIM(o2.FName)) as Fname1,LTRIM(RTRIM(t2.FContact)) as FContact,LTRIM(RTRIM(v2.FName)) as Fname2,LTRIM(RTRIM(t2.FShortName)) as FShortName,t2.fnumber
,substring(t2.fnumber, 1,4) as CityID,t2.Fcorperate, o2.FName AS PaymentTerm, e2.FName AS EmpName
from AIS20041216164951.dbo.t_organization t2
left join
AIS20041216164951.dbo.t_Emp e2 ON t2.Femployee = e2.FItemID LEFT OUTER JOIN
AIS20041216164951.dbo.t_settle o2
on t2.FsetID=o2.FitemID
left join AIS20041216164951.dbo.t_submessage v2
on t2.FRegionID=v2.FInterID
where t2.FNumber like ‘C%’) as emp where EmpName<>” and EmpName is not null
后面的分别是参照 表中的Name,然后添加 然后将表中PernnelID中的值添加到这里，改字段名为id,后面的 ，里面为
zerop=”;
if (sequence<100)
zerop=’0′;
if (sequence<10)
zerop=’00’;
和前面稍微有点点不同就是添加了一层，sequence<100.
PersonnelID=zerop+trim(sequence);
这个地方和前面的不同点是没有加字符串’PM-’.最后看 ，
更新的是AR中的Personnel表，以字段Name为参照，以流中的EmpName和PersonnelID替换表中的Name和PersonnelID的值
19.现在开始，我开第19个transform
打开这个tranform,这个是最后一个比较复杂的transform了,而且这个transform是在前面那两个transform的基础上，才能运行的，看到这个表输入中的代码
Select
substring(t.fnumber, 1,1)+substring(t.fnumber, 4,1)+ substring(t.fnumber, 6,4) as abbr,LTRIM(RTRIM(t.FName)) as CustName,LTRIM(RTRIM(t.FAddress)) as FAddress,LTRIM(RTRIM(t.FPhone)) as FPhone,LTRIM(RTRIM(t.Ffax))as Ffax,
LTRIM(RTRIM(o.FName)) as Fname1,LTRIM(RTRIM(t.FContact)) as FContact,LTRIM(RTRIM(v.FName)) as Fname2,LTRIM(RTRIM(t.FShortName)) as FShortName,t.fnumber
,substring(t.fnumber, 1,4) as CityID,t.Fcorperate, o.FName AS PaymentTerm, e.FName AS EmpName
from AIS20040902164905.dbo.t_organization t
left join
AIS20040902164905.dbo.t_Emp e ON t.Femployee = e.FItemID LEFT OUTER JOIN
AIS20040902164905.dbo.t_settle o
on t.FsetID=o.FitemID
left join AIS20040902164905.dbo.t_submessage v
on t.FRegionID=v.FInterID
where t.FNumber like ‘B%’
union
Select
substring(t2.fnumber, 3,2)+ substring(t2.fnumber, 6,4) as abbr,LTRIM(RTRIM(t2.FName)) as CustName,LTRIM(RTRIM(t2.FAddress)) as FAddress,LTRIM(RTRIM(t2.FPhone)) as FPhone,LTRIM(RTRIM(t2.Ffax))as Ffax,
LTRIM(RTRIM(o2.FName)) as Fname1,LTRIM(RTRIM(t2.FContact)) as FContact,LTRIM(RTRIM(v2.FName)) as Fname2,LTRIM(RTRIM(t2.FShortName)) as FShortName,t2.fnumber
,substring(t2.fnumber, 1,4) as CityID,t2.Fcorperate, o2.FName AS PaymentTerm, e2.FName AS EmpName
from AIS20041216164951.dbo.t_organization t2
left join
AIS20041216164951.dbo.t_Emp e2 ON t2.Femployee = e2.FItemID LEFT OUTER JOIN
AIS20041216164951.dbo.t_settle o2
on t2.FsetID=o2.FitemID
left join AIS20041216164951.dbo.t_submessage v2
on t2.FRegionID=v2.FInterID
where t2.FNumber like ‘C%’;
这里分成上下两部分，上面部分是从AIS20040902164905,数据库中抽取数据，下面部分是从AIS20041216164951中抽取数据，所以看着段眼花缭乱的代码的时候，先把代码分开，不论是多么复杂的查询，都是一部分一部分，非常有条理的，而且越是长的代码，这种逻辑就越清晰。多的只是数据库，表，字段，连接而已。现在回顾一下LEFT OUTER JOIN，和LEFT JOIN的区别，前面这个是左表中的所有字段加上右表中在左表中没有的字段，而那些左表中有的字段就不需要，而后面的相反，是左表中有的字段加上右表中在左表中都有的字段的值。
这个表输入，是从以K3_HK为连接的两个数据库中导入客户相关资料，
筛选了如做截图中的15个字段，并对funumber和CustName进行了重新命名为Notes和full_name, 这个是用来添加字段的，上面部分的，添加了
Cust_Name=CustName.getString();
Eng_Name=CustName.getString();
Cust_Name=trim(Cust_Name);
Eng_Name=trim(Eng_Name);
if (!(/^[^\u4e00-\u9fa5]+$/.test(Cust_Name)) )
{
Eng_Name=null;
}
Cust_Name和Eng_Name两个字段，他们取值的来源为客户关系中的Cust_Name.另外一个代码如下
Cust_Name =CustName.getString().substr(CustName.getString().indexOf(“<“),CustName.getString().indexOf(“>”));
Cust_Name= Cust_Name.replace(“>”,””);
Cust_Name= Cust_Name.replace(“<“,””);
Eng_Name=CustName.getString().substr(0,CustName.getString().indexOf(“<“));
Eng_Name=trim(Eng_Name);
Cust_Name=trim(Cust_Name);
上面代码的意思是添加两个字段Cust_Name和Eng_Name,并且在从Cust_Name获取值得基础上，加上“<” 和“>”。
再看后面这一段复杂点的 ,这个ＪＳ并没有添加字段了，
function transCol2ToCol1(col, num)
{
var trimedcol2;
var col2length;
if(col==null||trim(col)==” “||trim(col)==””)
{
return ” “;
}
trimedcol2=trim(col.replaceAll(“[^\x00-\xff]”,”11″));
col2length=trimedcol2.length;
var ch,bytenum=0;
var rs = “”;
var pt = /[^\x00-\xff]/;
for (var i=0; i < num; i++)
{
ch = col.substr(i, 1);
if (ch.match(pt))
{
bytenum += 2;
if (bytenum > num)
{
return rs;
}
}
else{
bytenum += 1;
}
rs += ch;
if (bytenum == num){
return rs;
}
}
return rs;
}
Cust_Name.setValue(transCol2ToCol1(Cust_Name.getString(),60));
if (Eng_Name.getString()==null||Eng_Name.getString()==””){
Eng_Name.setValue(Cust_Name.getString());
Eng_Name.setValue(transCol2ToCol1(Eng_Name.getString(),100));
上面这个函数在名船务系统发票的那编号为２的transform中已经写过了，至于这里整个entry的作用，就是将新建的字段顺序更换。
看后面的 ，其中选取了流中的15个字段，显然，有些字段过滤掉了，划线的是新添加的字段
看后面的 ，里面是参照AR中的Personne表中的 Name字段，对应于流中的EmpName字段，添加了Personnel表中的Personnel表中的 PersonnelID字段，后面的
添加的是AR中paytype表中的PaytypeId字段，参照的是paytype字段。最后一个entry, 用流中 的字段更新数据表中原有的字段和字段取值。这个表为AR里面的customer表。好了，现在，回顾一下这整个transform所做的任务：开始，表输入从K3_HK中抽取有关客户的字段和数据，然后过滤掉那些无效数据，生成两个新字段，再分别从AR数据库中的customer表和Personnel选出两个字段，最后将数据表创建在AR上名为customer.
20.现在开始，看第20个tranform
从K3导入供应商这个tranform,里面并没有前面那个tranform涉及到那么复杂 ，一个表输入，一个数据输出
先看表输入里面的代码
SELECT FItemID, FAddress, FCity, FProvince, FCountry, FPostalCode, FPhone, FFax, FEmail, FHomePage, FCreditLimit, FTaxID, FBank, FAccount, FBrNo, FBoundAttr,
FErpClsID, FShortName, FPriorityID, FPOGroupID, FStatus, FLanguageID, FRegionID, FTrade, FMinPOValue, FMaxDebitDate, FLegalPerson, FContact, FContactAcct,
FPhoneAcct, FFaxAcct, FZipAcct, FEmailAcct, FAddrAcct, FTax, FCyID, FSetID, FSetDLineID, FTaxNum, FPriceClsID, FOperID, FCIQNumber, FDeleted, FSaleMode,
FName, FNumber, FParentID, FShortNumber, FARAccountID, FAPAccountID, FpreAcctID, FlastTradeAmount, FLastRPAmount, FFavorPolicy, Fdepartment, Femployee,
Fcorperate, FBeginTradeDate, FEndTradeDate, FLastTradeDate, FLastReceiveDate, FcashDiscount, FcurrencyID, FMaxDealAmount, FMinForeReceiveRate,
FMinReserveRate, FMaxForePayAmount, FMaxForePayRate, FdebtLevel, FCreditDays, FValueAddRate, FPayTaxAcctID, FModifyTime, F_102
FROM t_Supplier
WHERE (FDeleted = 0)
容易看出来，这是从t_Supplies中抽取那些没有标记为删除的数据。从这里将数据抽取出来之后，是抽取了流中的如下数据然后送入到AR中provider表中
这个transform就是从k3中的供应商里面的表里的数据抽取到AR数据库中的provider表中。
21.现在开始，我看第21个tranform
打开这个tranform，里面有两个表输入
这第一个表输输入里面是从2.252的import_temp_ar_hk中抽取INVOICE_NO和INVOICE_AMOUNT总和，
SELECT INVOICE_NO, SUM(INVOICE_AMOUNT) AS SUM_AMOUNT
FROM import_temp_ar_hk
GROUP BY INVOICE_NO
第二个表输入是从2.252的import_temp中抽取INVOICE_NO和INVOICE_AMOUNT总和
SELECT INVOICE_NO, SUM(INVOICE_AMOUNT) AS SUM_AMOUNT
FROM import_temp
WHERE IMPORT_STATUS >=0 and INVOICE_DATE>=’2011-1-1′
GROUP BY INVOICE_NO
后面的 是将INVOICE_NO中所有英文字符变成大写， 将INVOICE_NO以升序排列，并且通过 将两个据流中的数据合并
最后将数据送入到2.252的ar_merge_sum表中，这是一个新建的表。
22.现在开始，我看第22个transform
因为这个transform涉及到的内容实在是太少了，是从刚才那个
ar_merger_sum中抽取INVOICE_NO字段，然后将ＡＲ中和这个INVOICE_NO相同的删除。
SELECT INVOICE_NO
FROM ar_merge_sum
23.现在开始，看第23个transform
这是ar_job中的最后一个transform了，里面只有一个表输入和一个表输出，
SELECT INVOICE_NO, FABRIC_NAME, MO_NO, CUST_NAME, INVOICE_TYPE, INVOICE_SUBTYPE, INVOICE_AMOUNT, INVOICE_DUEDATE,
INVOICE_CURRENCY, INVOICE_PAYMENTTERM, INVOICE_DEPT, INVOICE_DATE, BUYER, LABEL, DIVISION, SEASON, DILIVERY_DATE, REQ_DATE,
CUSTOMER_MR, GARMENT_NO, STYLE_NO, SALES_BY, REGION, VATNO_DJ, PO, MR, QTY2, QTY2_UNIT, QUANTITY, QUANTITY_UNIT,
PAYMENT_QTY, FOC_QTY, UNIT_DJ, FOC_AMT, COMMISSION, DISCOUNT, PORT_NAME, REF_PRICE, REF_QUANTITY_UNIT, SAMPLE_TYPE,
LAST_SHIP_DATE, SHIPPED_QTY, REMARKS, PI_PRICE, PI_PRICE_CURRENCY, PI_QTY, PI_QTY_UNIT,2 as IMPORT_STATUS
FROM import_temp
WHERE INVOICE_NO in(SELECT INVOICE_NO FROM ar_merge_sum)
表输入是将2.252中import_temp中的数据输入到流中
表输出是将表输入的数据输入到AR中的Import_temp,这样，所有的工作都完成了。到这里ar_job就完成了。
24.现在开始，看第24个transform
这里是ar_datacompare_job的开始，这里的前提条件是要前面的ar_job正常执行完所有transform之后，才能执行的。现在打开ar_xls,
这是11个excels表的数据经过筛选合并到2.252中的ar_xls_export_pre
表中的过程，这些excel可能是会计过程中计算出来的excel表。
因为涉及到的excel表有点多，但是各个excel到达终表的过程中的处理是一样的，这里最终筛选出来的字段就只有四个,INVOICE_DATE,INVOICE_NO,INVOICE_AMOUNT,INVOICE_CURRENCY.
25.现在开始，看第25个transform
这个transform也很简单，一个表输入和一个表输出，是在前面的transform的基础上，进行数据筛选
SELECT invoice_no, CONVERT (datetime,CAST ( DATEPART(dd,xls.invoicedate) AS varchar) +’/’+
CAST ( DATEPART(mm,xls.invoicedate) AS varchar) +’/’+
CAST ( DATEPART(yyyy,xls.invoicedate) AS varchar) ,103) as invoice_date
, invoice_amount,invoice_currency
FROM
(SELECT [invoice_no]
,[invoice_date]
,CAST ( [invoice_date] AS datetime ) as [invoicedate]
,[invoice_amount]
,[invoice_currency]
FROM [ar_xls_export_pre]
where [invoice_no] not like ‘H%’
union all
SELECT [invoice_no]
,[invoice_date]
,CONVERT (datetime, [invoice_date] ,103) as [invoicedate]
,[invoice_amount]
,[invoice_currency]
FROM [ar_xls_export_pre]
where [invoice_no] like ‘H%’)
as xls
将上一个transform中产生的ar_xls_export_pre表中的数据输入到另外一个叫做2.252的ar_xls_export表中。
26. 现在开始,看第26个transform
这是这个AR中最后一个transform了，
下面是这个表输入中的SQL
SELECT CONVERT (datetime,CAST ( DATEPART(dd,FillDate) AS varchar) +’/’+
CAST ( DATEPART(mm,FillDate) AS varchar) +’/’+
CAST ( DATEPART(yyyy,FillDate) AS varchar) ,103) as invoice_date1, INVOICE_NO, Currencyid, currtotal
FROM invoice_out
这里面从AR的invoice_out表中共筛选了invoice_date1, INVOICE_NO, Currencyid, currtotal四个字段，参照的字段是是ＡＲ中Currentid字段 加入的是 currencynm字段，最后将数据放入到了2.252的INVOICE_OUT中。
原文链接：https://www.cnblogs.com/canyangfeixue/archive/2013/01/18/2866080.html
原创文章，作者：优速盾-小U，如若转载，请注明出处：https://www.cdnb.net/bbs/archives/3533
