测试数据如下



1085  proc sql;
1086  create table abcom AS
1087  select a.* from  a inner join b
1088  on  a.x=b.x;
NOTE: 表 WORK.ABCOM 创建完成，有 2001228 行，3 列。
1089  ;
1090  quit;
NOTE: “PROCEDURE SQL”所用时间（总处理时间）:
      实际时间         4.56 秒
      CPU 时间         4.61 秒

1091  data d;
1092      if _N_=1 then do;
1093          declare hash h1(dataset:"work.b");
1094          declare hiter i1("h1");
1095          h1.definekey("x");
1096          h1.definedata("x");
1097          h1.definedone();
1098      end;
1099
1100      set a end=EOF;
1101
1102      rc=h1.find();
1103      if rc=0 then output;
1104
1105      keep x y z;
1106  run;
NOTE: 从数据集 WORK.B 读取了 200 个观测。
NOTE: 从数据集 WORK.A 读取了 10000000 个观测。
NOTE: 数据集 WORK.D 有 2001228 个观测和 3 个变量。
NOTE: “DATA 语句”所用时间（总处理时间）:
      实际时间         6.34 秒
      CPU 时间         4.00 秒

1107  proc sql;
1108
1109  create table newAB as
1110
1111    select a.* from a
1112
1113     where exists (select *
1114
1115              from b
1116
1117              where a.x = b.x);
NOTE: 表 WORK.NEWAB 创建完成，有 2001228 行，3 列。
1118
1119  quit;
NOTE: “PROCEDURE SQL”所用时间（总处理时间）:
      实际时间         2:52.17
      CPU 时间         2:52.01

1120
1121  proc sql;
1122
1123  create table newAB as
1124
1125    select a.* from a
1126
1127     where x in (select x
1128
1129              from b
1130
1131              );
NOTE: 表 WORK.NEWAB 创建完成，有 2001228 行，3 列。
1132
1133  quit;
NOTE: “PROCEDURE SQL”所用时间（总处理时间）:
      实际时间         14.56 秒
      CPU 时间         14.53 秒

1134  proc sort data=a;by x;run;
NOTE: 从数据集 WORK.A 读取了 10000000 个观测。
NOTE: 数据集 WORK.A 有 10000000 个观测和 3 个变量。
NOTE: “PROCEDURE SORT”所用时间（总处理时间）:
      实际时间         13.93 秒
      CPU 时间         14.71 秒

1134!                           quit;
1135  proc sort data=b;by x;run;
NOTE: 从数据集 WORK.B 读取了 200 个观测。
NOTE: 数据集 WORK.B 有 200 个观测和 1 个变量。
NOTE: “PROCEDURE SORT”所用时间（总处理时间）:
      实际时间         0.01 秒
      CPU 时间         0.01 秒

1135!                           quit;
1136
1137  data ccc;
1138      merge a(in=a1) b(in=b1);
1139      by x;
1140      if a1 and b1;
1141  run;
NOTE: 从数据集 WORK.A 读取了 10000000 个观测。
NOTE: 从数据集 WORK.B 读取了 200 个观测。
NOTE: 数据集 WORK.CCC 有 2001228 个观测和 3 个变量。
NOTE: “DATA 语句”所用时间（总处理时间）:
      实际时间         2.98 秒
      CPU 时间         2.96 秒

可能的效率打分
A   inner join
A -  hash
B   in subquery
B+ sort+merge
？？where exist

对于海量数据，我个人偏好于各种join
hash在处理一多对应时需要相应修改
sort+merge比较不感冒。。。个人喜好

7# soporaeternus

Thanks for letting me know. Learn hash from you. Bless.

There are many good answers posted for this problem. There is another good way to solve it IMO. It uses SAS formats. Here is the result.
As long as the keys are not many. Compiling a SAS format takes no time. You may see at the bottom that format approach beats all others if the keys can be expressed in a range.

526  proc sql noprint;
527  select x into: keepid separated by ','
528  from b;
529  quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds


530
531  proc format;
532  value keys
533   &keepid='1'
534  other ='0'
535  ;
NOTE: Format KEYS is already on the library.
NOTE: Format KEYS has been output.
536  run;

NOTE: PROCEDURE FORMAT used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds


537
538  data d;
539   do until(end);
540     set a end=end;
541     if put(x,keys.)='1' then output;
542  end;
543  run;

NOTE: There were 10000000 observations read from the data set WORK.A.
NOTE: The data set WORK.D has 2000612 observations and 3 variables.
NOTE: DATA statement used (Total process time):
      real time           6.48 seconds
      cpu time            6.46 seconds


544
545  proc sql;
546   create table d AS
547    select a.* from  b inner join a
548    on  a.x=b.x;
NOTE: Table WORK.D created, with 2000612 rows and 3 columns.

549   ;
550   quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           6.25 seconds
      cpu time            5.98 seconds


551
552   data d;
553      if _N_=1 then do;
554          declare hash h1(dataset:"work.b");
555          declare hiter i1("h1");
556          h1.definekey("x");
557          h1.definedata("x");
558          h1.definedone();
559      end;
560
561      set a end=EOF;
562
563      rc=h1.find();
564      if rc=0 then output;
565
566      keep x y z;
567  run;

NOTE: There were 200 observations read from the data set WORK.B.
NOTE: There were 10000000 observations read from the data set WORK.A.
NOTE: The data set WORK.D has 2000612 observations and 3 variables.
NOTE: DATA statement used (Total process time):
      real time           5.93 seconds
      cpu time            5.93 seconds


568
569  proc format;
570  value keys
571   1-200='1'
572  other ='0'
573  ;
NOTE: Format KEYS is already on the library.
NOTE: Format KEYS has been output.
574  run;

NOTE: PROCEDURE FORMAT used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds


575
576  data d;
577   do until(end);
578     set a end=end;
579     if put(x,keys.)='1' then output;
580  end;
581  run;

NOTE: There were 10000000 observations read from the data set WORK.A.
NOTE: The data set WORK.D has 2000612 observations and 3 variables.
NOTE: DATA statement used (Total process time):
      real time           5.43 seconds
      cpu time            4.39 seconds

9# bobguy
format的用法学习了
以前SAS的人来做项目的时候，是说过类似的replace是format效率最高。。。。。。
学习了

说到方法的话，把b表表达成if else组合，在set a的时候调用，会不会也不错，等等有空测试下。。。。。。

长知识了！！！

I believe that if making an index  on the key ( in this case x ) in table a may be a better choice if there are high frequency similar queries. 等 (you) 有空测试.

data c;
input company year price;
cards;
1  1  3
1  2  5
2  1  2
2  2  3
3  1  3
3  2  7
;run;
data d;
input company;
cards;
2
3
;run;
proc sql;
create table f as
select * from c join d on c.company=d.company;
run;