繁体   English   中英

关于如何处理格式为JSON之类的AST的指南

[英]Guide on how to process AST formatted as JSON like structure

通过在Perl中use SQL::Abstract::Tree ,我可以通过以下方式为SQL生成AST:

my $sqlat = SQL::Abstract::Tree->new;
my $tree = $sqlat->parse($query_str);

其中$query_str是一个SQL查询。

例如,使用查询字符串SELECT cust_id, a as A, z SUM(price) as q, from orders WHERE status > 55 ,生成:

[
  [
    "SELECT",
    [
      [
        "-LIST",
        [
          ["-LITERAL", ["cust_id"]],
          ["AS", [["-LITERAL", ["a"]], ["-LITERAL", ["A"]]]],
          [
            "AS",
            [
              ["-LITERAL", ["z"]],
              ["SUM", [["-PAREN", [["-LITERAL", ["price"]]]]]],
              ["-LITERAL", ["q"]],
            ],
          ],
          [],
        ],
      ],
    ],
  ],
  ["FROM", [["-LITERAL", ["orders"]]]],
  [
    "WHERE",
    [[">", [["-LITERAL", ["status"]], ["-LITERAL", [55]]]]],
  ],
]

我想了解一下AST并获取有关它的某些信息。

我想知道是否有一种指南/教程/示例源代码以这种格式传递AST。

我发现考虑步行AST的大多数文献通常都假设我具有某种类层次结构,该类层次结构描述了步行AST的访客模式的某种变化。

我的特定用例是将简单SQL查询转换为聚合框架的Mongo查询,并在此处给出一些示例。

到目前为止,这是我一直在做的事情:

我首先调用一个parse函数,并在给定每个子树的类型和类型(这是每个子树中的第一个参数)的基础上对树进行调度,然后将其与树的其余部分一起调用。 这是我的parse函数:

sub parse {
    my ($tree) = @_;

    my %results = (ret => []);
    for my $subtree (@$tree) {
        my ($node_type, $node) = @$subtree;

        my $result_dic = $dispatch{$node_type}->($node);
        if ($result_dic->{type}) {
             my $type = $result_dic->{type};
             $results{$type} = [] unless $results{$type};
             push $results{$type}, $result_dic->{ret};
             %results = merge_except_for($result_dic, \%results, 'ret', $type);
         }
         else {
             push @{$results{ret}}, @{$result_dic->{ret}};
         }

    }


    return \%results;

}

它使用以下调度表:

my %dispatch = (
    SELECT => sub {

        my $node = shift;
        my $result_dic = parse($node);
        $result_dic->{type} = 'select';
        if ($result_dic->{as}) {
             push $result_dic->{ret}, $result_dic->{as}->[0][0];
         }
        return $result_dic;
    },
    '-LITERAL' => sub {
        my $node = shift;
        my $literal = $node;
        return {ret => $node};
    },
    '-LIST' => sub {
        my $node = shift;
        my $result_dic = parse($node);

        my $ret = flatten_ret($result_dic);

        return flatten_ret($result_dic);
    },
    WHERE => sub {
        my $tree = shift;
        my @bin_ops = qw/= <= < >= >/;

        my $op = $tree->[0];
        if ($op ~~ @bin_ops) {
            # Not yet implemented
        }
        return {ret => ''};

    },
    FROM => sub {
        my $tree = shift;
        my $parse_result = parse($tree);
        return {ret => $parse_result->{ret},
                type => 'database'};
    },
    AS => sub {
        my $node = shift;

        my $result_dic = parse($node);
        $result_dic->{type} = 'as';
        return $result_dic;
    }
);

sub flatten_ret {
    my $result_dic = shift;

    return {ret => [
        map {
            ref($_) ? $_->[0] : $_
        } @{$result_dic->{ret}}]};
}

但是我不确定某些事情,例如我是否应该检查SELECT子例程中的节点名称是否为"AS" ,还是寻找一种递归填充数据的方法。

另外,每个调度调用应返回哪种类型的数据,最后如何合并?

另外,我是AST处理的新手,并且希望能掌握它,因此,对于如何改善问题的建议也将不胜感激。

您进行类型分派的想法大致正确。 通常,人们可能会在其上使用对象并使用分派方法。 但是,使用两个元素的列表标记某种类型的数据也可以。 您错误的parse函数将实现此分派,并以某种方式聚合输出。 我不太确定您要达到的目标。

进行AST转换时,记住要创建的确切输出非常有用。 假设您要转换

SELECT cust_id, a as A, SUM(price) as q from orders WHERE status > 55

进入数据结构

{
  table  => 'orders',
  action => 'aggregate',
  query  => [
    '$match' => { 'status' => { '$gt' => 55 } },
    '$group' => {
       '_id'     => undef,
       'cust_id' => '$cust_id',
       'A'       => '$a',
       'q'       => { '$sum' => '$price' },
    },
  ],
}

为此我们需要做什么?

  • 断言我们有一个SELECT ... FROM ...类型查询。
  • 将操作设置为aggregate
  • 提取FROM条目的表名
  • 组装查询:
    • 对于每个SELECT项,获取名称以及产生该值的表达式。
      • 递归构建每个表达式
    • 如果存在WHERE子句,则递归转换每个条件。

如果遇到无法解析的语法,则会引发错误。

请注意,我的方法从顶部开始,并在需要时从AST的更深层提取信息。 这与您自下而上的方法相反,后者将所有数据汇总在一起,并希望最后有相关内容。 尤其是您的哈希合并看起来令人怀疑。

如何实现呢? 这是一个开始:

use Carp;

sub translate_select_statement {
  my ($select, $from, @other_clauses) = @_;
  $select->[0] eq 'SELECT'
    or croak "First clause must be a SELECT clause, not $select->[0]";
  $from->[0] eq 'FROM'
    or croak "Second clause must be a FROM clause, not $from->[0]";

  my $select_list = $select->[1];
  my %groups = (
    _id => undef,
    translate_select_list(get_list_items($select_list)),
  );

  ...
}

sub get_list_items {
  my ($list) = @_;
  if ($list->[0] eq '-LIST') {
    return @{ $list->[1] };
  }
  else {
    # so it's probably just a single item
    return $list;
  }
};

sub translate_select_list {
  my %out;
  for my $item (@_) {
    my ($type, $data) = @$item;
    if ($type eq '-LITERAL') {
      my ($name) = @$data;
      $out{$name} = '$' . $name;
    }
    elsif ($type eq '-AS') {
      my ($expr, $name_literal) = @$data;
      $name_literal->[0] eq '-LITERAL'
        or croak "in 'x AS y' expression, y must be a literal, but it was $name_literal->[0]";
      $out{$name_literal->[1][0]} = translate_expression($expr);
    }
    else {
      croak "I select list, items must be literals or 'x AS y' expression. Found [$type, $data] instead.";
    }
  }
  return %out;
}

sub translate_expression { ... }

我的构造方式更像是自上而下的解析器,但是例如对于算术表达式的翻译,类型分配更为重要。 在上面的代码中, if / else情况更好,因为它们允许更多的验证。

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM