报表的核心是数据，数据集是否合理决定报表的质量。     

1.每张报表都应该有一个主数据集，为了降低维护时的工作量，尽量将所有字段置于主数据集，除非在某些情况下，不使用多源数据集会导致主数据集异常复杂。

2.在制作报表之前，尽量考虑到所有需要展示的数据字段，在数据库软件中，合理编写 SQL 语句，大数据情况尽量对 SQL 做优化，以及添加索引。

设计器拼出最终的 SQL，将 SQL 语句传给数据库，数据库执行，将数据返回给设计器。

由于计算过程首先要通过 SQL 语句从数据库中取数据，我们可以通过控制数据量的大小和对数据的提前预处理来提高报表的性能。

FineReport 报表的数据集采用的是表模型，也就是说通过 SQL 这种 DSL 语言，从数据库通过简单查询或各种组合关联查询得到一个关系表，而这部分 SQL 查询根据各种数据库厂商长时间的优化(比如建立索引)，已经非常成熟。数据集一般要通过FineReport报表模型的复杂处理才能生成最终的表样。因此，从数据库 SQL 查询取出数据量越少，FineReport 报表模型需要做的复杂处理和计算就越少，所花的时间和内存就少，从而可以提高性能。

3.1 SQL 语句取具体的字段

我们一般会用select * from 这样的形式将一个数据库表中所有的字段都取出来，而其中一些字段是报表中不需要用到的，例如报表中只需要用到三个字段，但是数据库中实际的表有十个字段，一些初学者习惯性的用select * from table1，这样相当于把十个字段的数据都取到报表服务器端，增加了报表服务器端的内存占用以及减慢了运算速度，所以 SQL 语句中尽量不要用“*”号，而是写上具体的字段，能够减少报表服务器端的内存占用，加快报表的运算速度。

3.2 SQL 中直接分组代替报表中分组

一些汇总类型的报表，例如制作一张订单总额的表，可能会从订单明细表中取出大量的数据记录，然后进行数据汇总，即进行分组聚集运算，报表计算过程中我们可以在 SQL 中提前进行一次分组聚集，能够大大减少取到的报表服务器的记录数，加快取数和报表运算的速度。

SQL 语句：SELECT 成本价,类别ID FROM 产品

从数据库中选择如上两个字段，然后根据类别 ID 进行成本价的汇总，此时数据库返回给报表处理的数据就有 76 条。如下：

优化的 SQL 语句：SELECT sum(成本价),类别ID FROM 产品 group by 类别ID

经过 SQL 优化后，报表需要处理的数据就只剩 8 条了。如下：

优化分析：

• 第一种做法，不仅仅取到报表服务器上记录数多了，取数速度慢，而且报表模型需要对表数据列进行分组运算，增加了报表运行时间；

• 第二种做法，数据库虽然要进行分组运算，但是数据库中有索引，运算速度快，且取到报表服务器端的记录数大大减少，取数速度大大加快，因此在报表模型进行分组运算的时候只要对很少的记录数进行，报表的运算速度大大加快了。

实验结果以及分析表明，第二种做法的性能远优于第一种。所以，分组应该尽量在 SQL 里进行。

3.3 SQL 中直接排序代替报表中排序

报表计算过程中很多时候需要对数据进行排序，虽然排序运算可以在报表端进行，不过我们还是建议在 SQL 中提前将数据排序，这是因为数据库中的索引功能，通常是 C/C++ 语言(往往在效率上比 Java 好)写的，会使得排序运算的速度很快。

3.4 SQL 中直接过滤代替报表中过滤

报表计算过程中很多时候并不需要对表中的所有记录进行操作，而只是需要对部分满足条件的记录进行操作，虽然可以在报表设计器中对数据过滤，不过我们建议在 SQL 中对数据提前过滤，这样数据库返回的数据就减少了，既加快了取数速度，也加快了报表的运算速度。

视图是由 SELECT 语句组成的查询定义的虚拟表，由一张或多张数据库实际的表中的数据组成的，从数据库系统外部来看，视图就如同一张表一样。

存储过程通过流控制与 SQL 语句，可以对数据进行强大的运算与处理，对于业务比较复杂的应用，常常需要将原始数据通过存储过程处理后再供报表使用。另外存储过程运行前，数据库会对其进行语法和句法的分析，并进行优化，这种已经编译好的存储过程极大地改善 SQL 语句的性能。在报表端也只需要书写较短的调用语句来获得结果，从而降低网络的通信量。

所以表与表的连接、复杂的SQL尽量在数据库中使用视图或者存储过程直接进行，这样将复杂的 SQL 语句直接保存于数据库服务器端（数据库本身会对 SQL 语句进行语法分析并进行优化），在报表设计器端就不需要写大段的 SQL 语句而是直接调用视图或存储过程了，一方面减少网络传输量，减轻数据库的压力，另一方面加快了报表的运算速度。

5.1 SELECT 子句中避免使用 “*”  

当你想在 SELECT 子句中列出所有的 COLUMN 时，使用动态 SQL 列引用‘*’是一个方便的方法。不幸的是，这是一个非常低效的方法。 实际上，ORACLE 在解析的过程中, 会将“*” 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间。  

5.2 删除重复记录！  

最高效的删除重复记录方法 ( 因为使用了 ROWID)

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID) FROM EMP X WHERE X.EMP_NO = E.EMP_NO)

5.3 用 TRUNCATE 替代 DELETE

 当删除表中的记录时，在通常情况下，回滚段(rollback segments ) 用来存放可以被恢复的信息，如果你没有 COMMIT 事务，Oracle 会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况)，而当运用 TRUNCATE 时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短.   

5.4 计算记录条数！

 和一般的观点相反 count(*) 比count(1)稍快 ，当然如果可以通过索引检索，对索引列的计数仍旧是最快的. 例如 COUNT(EMPNO)   

5.5 用 EXISTS 替代 IN

在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用 EXISTS (或 NOT EXISTS)通常将提高查询的效率. 

• 低效    

       SELECT * FROM EMP WHERE EMPNO > 0 AND DEPTNO IN (SELECT DEPTNO FROM DEPT WHERE LOC =’MELB’)   

• 高效

       SELECT * FROM EMP WHERE EMPNO > 0 AND EXISTS (SELECT ‘X’  FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB’)   

5.6 用 EXISTS 替换 DISTINCT  

当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在 SELECT 子句中使用 DISTINCT. 一般可以考虑用 EXIST 替换  例如:   

• 低效:     

       SELECT DISTINCT DEPT_NO,DEPT_NAME  FROM DEPT D,EMP E WHERE D.DEPT_NO = E.DEPT_NO 

• 高效:    

       SELECT DEPT_NO,DEPT_NAME  FROM DEPT D WHERE EXISTS ( SELECT ‘X’ FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO)  

• EXISTS 使查询更为迅速

5.7 用>=替代>

--如果 DEPTNO 上有一个索引    

• 高效：    

   SELECT *  FROM EMP  WHERE DEPTNO >=4    

• 低效：    

   SELECT *  FROM EMP   WHERE DEPTNO >3    

   两者的区别在于, 前者 DBMS 将直接跳到第一个 DEPT 等于 4 的记录而后者将首先定位到 DEPTNO=3 的记录并且向前扫描到第一个 DEPT 大于 3 的记录.

5.8 应尽量避免在 where 子句中对字段判断!

如：

select id from t where num is null

可以在 num 上设置默认值 0，确保表中 num 列没有 null 值，然后这样查询：

select id from t where num=0

5.9 应避免在 where 中使用!=或<>操作符

将导致引擎放弃使用索引而进行全表扫描。优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。

5.10 应避免在 where 子句中使用 or 连接!

否则将导致引擎放弃使用索引而进行全表扫描，如：

select id from t where num=10 or num=20

可以这样查询：

select id from t where num=10 union all select id from t where num=20

5.11 in 和 not in 也要慎用!

因为 in 会使系统无法使用索引,而只能直接搜索表中的数据。如：

select id from t where num in(1,2,3)

对于连续的数值，能用 between 就不要用 in 了：

select id from t where num between 1 and 3

5.12 应避免在 where 中进行表达式操作!

这将导致引擎放弃使用索引而进行全表扫描。如：

SELECT * FROM T1 WHERE F1/2=100

应改为:

SELECT * FROM T1 WHERE F1=100*2

SELECT * FROM RECORD WHERE SUBSTRING(CARD_NO,1,4)=’5378’

应改为:

SELECT * FROM RECORD WHERE CARD_NO LIKE ‘5378%’

SELECT member_number, first_name, last_name FROM members WHERE DATEDIFF(yy,dateofbirth,GETDATE()) > 21

应改为:

SELECT member_number, first_name, last_name FROM members WHERE dateofbirth < DATEADD(yy,-21,GETDATE())

即：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

5.13 应避免在 where 子句中进行函数操作！

这将导致引擎放弃使用索引而进行全表扫描。如：

select id from t where substring(name,1,3)='abc'

--name 以 abc 开头的 id

select id from t where datediff(day,createdate,'2005-11-30')=0

--‘2005-11-30’生成的id

应改为:

select id from t where name like 'abc%'

select id from t where createdate>=’2005-11-30′ and createdate<'2005-12-1'

5.14 不要在 where 中的“=”左边运算！

进行函数、算术运算或其他表达式运算，系统将可能无法正确使用索引。

5.15 尽量避免向客户端返回大数据量！

若数据量过大，应该考虑相应需求是否合理。

5.16 避免使用不兼容的数据类型！

例如 float 和 int、char 和 varchar、binary 和 varbinary 是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。例如:

SELECT name FROM employee WHERE salary > 60000

在这条语句中,如 salary 字段是 money 型的,则优化器很难对其进行优化,因为 60000 是个整型数。我们应当在编程时将整型转化成为钱币型,而不要等到运行时转化。

5.17 充分利用连接条件！

在某种情况下，两个表之间可能不只一个的连接条件，这时在 WHERE 子句中将连接条件完整的写上，有可能大大提高查询速度。

例：

SELECT SUM(A.AMOUNT) FROM ACCOUNT A,CARD B WHERE A.CARD_NO = B.CARD_NO

SELECT SUM(A.AMOUNT) FROM ACCOUNT A,CARD B WHERE A.CARD_NO = B.CARD_NO AND A.ACCOUNT_NO=B.ACCOUNT_NO

第二句将比第一句执行快得多。

5.18 能用 GROUP BY 的就不用 DISTINCT

SELECT DISTINCT OrderID FROM Details WHERE UnitPrice > 10

可改为：

SELECT OrderID FROM Details WHERE UnitPrice > 10 GROUP BY OrderID

5.19 能用 UNION ALL 就不要用 UNION！

UNION ALL 不执行 SELECT DISTINCT 函数，这样就会减少很多不必要的资源

5.20 尽量不要用 SELECT INTO 语句！

SELECT INTO 语句会导致表锁定，阻止其他用户访问该表。