集算器和R语言处理外存文本文件的对比

  作为数据计算语言，集算器和R语言都提供了丰富的功能用来处理外存中的文本文件。两者在基本用法上有很多相似之处，但区别也很明显，比如处理列宽固定的文件、读写指定的列、处理大文本文件，计算性能等方面。下面详细对比两者的异同。

1、基本功能对比

  描述：

  sales.txt共有六列，列之间以制表符（\t）分割，行之间以换行符（\n）分割，其中第一行为列名。请将该文件读入内存，再原样写入新的文件。该文件的前几行如下：

 

  集算器：

    data=file(“e:\\sales.txt”).import@t()

    file(“e:\\salesResult.txt”).export@t(data)

  R语言：

    data<-read.table(“e:\\sales.txt”,sep=”\t”, header=TRUE)

    write.table(data, file=”e:\\ salesResult.txt”,sep=”\t”,quote=FALSE,row.names=FALSE)

  对比：

  （1）两者都可以方便地实现本功能，其中集算器需要用函数选项“@t”表示第一行为列名，而R语言使用“header=TURE”。

  （2）换行符是最常见的行分割符，集算器和R语言默认支持换行符。制表符是最常见的列分割符，集算器默认支持制表符，如需指定其他分割符（比如逗号）则应当写作“import@t(;”,”)”。R语言支持的默认列分隔符是“空格和制表符”，这会把含有空格的Client列错误地分为两列，因此需要用sep=”\t”来明确分割符只能是制表符。另外，代码中的“quote=FALSE,row.names=FALSE”表示和源文件一样，不用给元素加引号，也不用输出行号。

  （3）文件被读到内存后一般都以结构化二维数据对象来存储，这在集算器中被称为序表（TSeq），在R语言中被称为数据框（data.frame）。序表和数据框都支持丰富的计算功能，比如按Client和SellerId分组，分组后对Amount求和并求最大值。集算器实现该算法的代码是：

  data.groups(Client,SellerId;sum(Amount),max(OrderID))

  数据框不直接支持同时使用多种汇总方法，因此求和、求最大值要分为两步，最后再通过cbind拼合结果，如下：

    result1<-aggregate(data[,4],data[c(2,3)],sum) 

    result2<-aggregate(data[,1],data[c(2,3)],max)

    result<-cbind(result1,result2[,3])

  （4）除内存中的结构化二维数据对象外，集算器还能用游标对象来访问文件，R则能用矩阵对象来访问文件。

  结论：对于基本的文件读写，集算器和序表都提供了足够丰富的函数功能，可以很好的满足需求。

2、读取列宽固定的文件

  有些文件没有分隔符来区分不同的列，而是用固定的宽度来区分。比如，请将下面含有三列数据的static.txt文件读入内存，并将列名分别改为： col1、col2、col3。其中，col1宽度为1，col2宽度为4，col3宽度为3。

    A1.501.2
    A1.551.3
    B1.601.4
    B1.651.5
    C1.701.6
    C1.751.7

  集算器：

    data=file(“e:\\static.txt”).import()

    data.new(mid(_1,1,1):col1, mid(_1,2,4):col2, mid(_1,6,8):col3)

  R语言：

  data<-read.fwf(“e:\\sales.txt “, widths=c(1, 4, 3),col.names=c(“col1″,”col2″,”col3″))

  对比：R语言可以直接实现本功能。集算器只能间接实现，即将文件读入内存后再拆分成多个列。请注意：代码mid(_1,1,1)中的”_1”是默认列名，如果读入的文件有多个列，则默认列名依次是：_1、_2、_3等。

  结论：R语言能够直接读取列宽固定的文件，比集算器更方便。

3、读写指定的列

  有时出于节省内存提高性能等目的，我们需要读取部分的列数据。本例需要将sales.txt中的ORDERID、CLIENT、AMOUNT这三列读入内存，并将ORDERID、AMOUNT写入新的文件。

  集算器：

    data=file(“e:\\sales.txt”).import@t(ORDERID,CLIENT,AMOUNT)

    file(“e:\\salesResult.txt”).export@t(data,ORDERID,AMOUNT)

  R语言：

    data<-read.table(“e:\\sales.txt”,sep=”\t”, header=TRUE)

    col3<-data[,c(“ORDERID”,”CLIENT”,”AMOUNT”)]

    col2<-col3[,c(“ORDERID”,”AMOUNT”)]

    write.table(col2, file=”e:\\ salesResult.txt”, sep=”\t”,quote=FALSE,row.names=FALSE)

  对比：集算器可以直接实现本功能。R语言只能间接实现，即将所有的列全部读入内存，再将指定的列存入新的变量。

  结论：R语言只能将所有的列全部读入内存，会占用较大的内存空间。

4、处理大文本文件

  大文本文件是指超过内存空间的文件。读取大文本文件通常要采取分批读取分批计算的办法。比如这个例子：针对大文本文件sales.txt，过滤出Amount>2000的数据，并计算每个SellerId的Amount总额。

  集算器

  A1：将大文件全部读入内存会导致内存溢出，因此用游标分批读入。

  A2：循环读数，每次读入100000条，存储于序表A2。

  B3：针对每批数据，过滤出订单金额在2000以上的记录。

  B4：接着对过滤后的数据进行分组汇总，求得这个批次每个销售员的销售额。

  B5：将本批次的计算结果追加到某个变量（B1）中，并进行下一批次的计算。

  B6：所有批次都计算完后，B1中应该存储着每个销售员在每个批次中的销售额，所以最后还要进行一次分组汇总，从而求得每个销售员的总销售额。

  R语言

1    colnames=c("ORDERID","CLIENT","SELLERID","AMOUNT","ORDERDATE")
2     mat=matrix(nrow=0,ncol=length(colnames))
3     data=as.data.frame(mat)
4     colnames(data)=colnames
5     
6     colnames=c("SELLERID","AMOUNT","x")
7     mat=matrix(nrow=0,ncol=length(colnames))
8     agg=as.data.frame(mat)
9     colnames(agg)=colnames
10    
11    con <- file("e:\\sales.txt ", "r")
12    readLines(con,n=1)
13    lines=readLines(con,n=100000)
14    while( length(lines) != 0) {
15      databatch<-data
16      for(line in lines){
17        row<-strsplit(line,'\t')
18        record<- data.frame(ORDERID=row[[1]][1],CLIENT=row[[1]][2],SELLERID=row[[1]][3], AMOUNT=as.numeric(row[[1]][4]), ORDERDATE=row[[1]][5])
19        databatch=rbind(databatch,record)
20      }
21      databatch <- databatch [databatch $AMOUNT>2000,]
22      aggbatch<-aggregate(databatch[,4],databatch[c(3)],sum)
23      agg<-rbind(agg,aggbatch)
24      lines=readLines(con,n=10)
25    }
26    
27    result<-aggregate(agg[,2],agg[c(1)],sum)

 

  1-4：建立空的数据框data，用来生成每批次的数据框databatch。

  5-9：建立空的数据框agg，用来追加各批次分组汇总的结果。

  11-13：按行读入文件，跳过第一行的列名，每次读入100000行。

  15-21：针对每批数据，过滤出订单金额在2000以上的记录。

  22：接着对过滤后的数据进行分组汇总，求得这个批次每个销售员的销售额。

  23：将本批次的计算结果追加到某个变量（agg）中，并进行下一批次的计算。

  24：所有批次都计算完后，B1中应该存储着每个销售员在每个批次中的销售额，所以最后还要进行一次分组汇总，从而求得每个销售员的总销售额。

  对比：

  （1）两者的算法思路一致，但集算器使用库函数就可以实现算法，代码简洁易懂，R语言则需要手工处理大量细节，代码繁杂冗长容易出错。

  （2）使用集算器游标，可以更简单地完成上述算法，即：

 

  在这段代码中，集算器引擎会自动分批处理数据，程序员无需用循环语句手工控制。

  结论：处理大文本文件时，集算器代码比R语言简洁易懂，方式更加灵活。

5、并行处理大文本文件

  并行计算可以充分利用多核CPU的资源，会显著提高计算性能。

  仍然使用上一节的例子来进行比较，但改为并行算法，即：将sales.txt分为4段，依次分给4个cpu核心计算，最终过滤出Amount>2000的数据，并计算每个SellerId的Amount总额。

  集算器：

  主程序（pro5.dfx）

 

  A1：并行任务数设为4，即将文件分为4段。

  A2：调用子程序进行多线程并行计算，任务参数有两个：to(A1)、A1。to(A1)的值是[1,2,3…24]，这表示每个任务分配到的段数；A1是总段数。所有任务都结束后，计算结果会统一存储在本单元格。

  A3：对A2中各任务的计算结果按照SellerId归并。

  A4：对归并结果进行分组汇总，求得每个销售员的销售额。

  子程序（sub.dfx）

 

  A1：用游标读取文件，按照主程序传来的参数决定当前任务应该处理文件中的第几段。比如第3个任务，segment参数的值就是3，total的值恒为4。

  A2：选出订单金额在2000以上的记录。

  A3：对过滤后的数据进行分组汇总。

  A4：将本任务的计算结果返回主程序。

  R语言

  无法直接用并行算法实现本案例。

  对比：

  集算器支持按照字节数分段读取大文本文件，可以快速跳过前面的无用数据而读取指定段，从底层起就支持多线程并行计算。

  R语言虽然支持内存数据的并行计算，但不支持按字节数分段读取外存文件，只支持跳过若干行再读取数据。这种方式必须遍历无用数据，性能很低，无法在底层支持大文本文件的并行计算。

  另外，按字节数分段会遇到半行数据的情况，而集算器已经对此进行了自动处理，如上述代码所示，程序员无需进行手工处理。

  总结：集算器支持并行处理大文本文件，计算性能很高。R语言无法在底层支持大文本文件的并行计算，性能差得多。

6、计算性能

  在同样的测试环境下，使用集算器和R语言读取字节数为1G的文件，并对其中一个字段进行汇总。

  集算器：

        =file(“d:/T21.txt”).cursor@p(#1:long)

        =A1.groups(;sum(#1))

  R语言

        con<- file(“d:/T21.txt”, “r”)
        lines=readLines(con,n=1024)
        value=0
        while( length(lines) != 0) {
                 for(line in lines){
                          data<-strsplit(line,’\t’)
                         value=value+as.numeric(data[[1]][1])
                 }
                 lines=readLines(con,n=1024)
        }
        print(value)
        close(con)

 

  对比：

  （1）集算器耗时26秒，R语言耗时9分47秒，两者的差距超出了一个数量级。

  （2）对于大文件的处理，R语言无法使用数据框对象和库函数，只能手工书写循环语句边读边算，因此性能很低。集算器可以直接使用游标对象和库函数，因此性能较高。处理小文件时两者的区别不会有这么大。

  总结：处理大文本文件时，集算器的性能大幅超过R语言。