147

我有一个函数 parseQuery，它将 SQL 查询解析为该查询的抽象表示。

我即将编写一个函数，该函数采用查询的抽象表示并返回 SQL 查询字符串。

我应该怎么称呼第二个功能？

4

33 回答 33

200

我认为您想要的动词是“撰写”。

于 2008-09-29T14:19:46.987 回答
78

parse的反面是序列化

于 2008-10-02T15:44:37.227 回答
32

在编译器术语中，相反的是“未解析”。具体来说，解析将令牌流转换为抽象语法树，而反解析将抽象语法树转换为令牌流。

于 2008-12-27T08:18:34.817 回答
31

撰写？解析查询时，您将其分解为其组成部分（令牌等），相反会将这些部分组合成字符串查询。

于 2008-09-29T14:21:20.417 回答
21

为了补充您现有的命名，composeQuery看起来最好。

但在一般情况下，parse的反义词是ǝsɹɐd

于 2012-03-08T22:01:35.567 回答
20

我会使用其中之一：

  • 字符串（）
  • ToSQL()
  • 使成为（）
于 2008-09-29T14:28:22.223 回答
17

我认为“序列化”可能是您想要的词。这意味着生成可以从程序中导出（和导入）的数据的文本表示。

于 2008-09-29T14:25:45.320 回答
15

“分析”的反义词是“综合”。

于 2008-09-29T14:20:14.897 回答
13

ToQueryString()

于 2008-09-29T14:19:34.600 回答
12

绝对渲染。

于 2008-10-15T14:18:29.980 回答
10

我称之为constructQuery。

于 2008-09-29T14:19:32.837 回答
10

可能产生或发射。

于 2008-09-29T14:19:58.297 回答
10

只是为了添加一些东西。

当然 parse 是一个双向词。

您可以将摘要解析为查询。

您可以将查询解析为摘要。

问题应该是，您将方法的后半部分命名为什么，因为在这种情况下，您正在解析一个摘要以进行查询，您将调用它parseAbstract。

要回答这个问题，解析没有对立面。

于 2008-09-29T15:56:06.273 回答
9

生成查询，可能吗？创建查询？

于 2008-09-29T14:19:30.560 回答
8

任你选

  • 产生
  • 倾倒
  • 连载
  • 发射

它们各自的内涵略有不同。

于 2012-03-14T20:43:56.183 回答
7

也许prettyPrintQuery？

于 2008-09-29T14:19:55.457 回答
7

compose、construction、generate、render、condense、reduce、toSQL、toString 取决于类及其相关运算符的性质

于 2008-09-29T16:21:02.797 回答
6

传统的编译器有两部分：解析器和代码生成器。

所以你可以称它为“生成”。当然，这里有点不同，因为编译器不编写源代码。（除非它是预编译器）。

于 2008-09-29T17:17:22.613 回答
5

可能是 Format()。还是您的实例中的 ToSQL()？

于 2008-09-29T14:19:31.120 回答
5

解解析（）？开个玩笑，我会选择 toQueryString()

于 2008-09-29T14:20:18.437 回答
4

压扁？

解析的查询对象可能表示条件层次结构，您将其“展平”回一维字符串。

但是鉴于您要从对象到字符串，实际上只需使用 toString 或 toSQL() 或类似的东西。此外，如果您设计得很好并且使用了正确的应用程序，您可以稍后重命名它，然后在评论中添加内容。

于 2008-09-29T15:00:01.447 回答
4

我会说序列化和反序列化，而不是解析和...

于 2008-09-29T19:29:37.257 回答
4

我会选择 ToString()，因为您通常可以将它们链式嵌套（相反的函数，可让您从 Class1 传递到 Class2，反之亦然）

DateTime.Parse( DateTime.Parse( myDate.ToString() ).ToString() );

Serialize() 看起来是个不错的选择，但在 Deserialize() 中已经有了相反的选择。

正如其他人指出的那样，在您的特定场景中， ToSql() 是另一个不错的选择。

于 2009-10-20T19:02:01.753 回答
4

我会使用渲染

> a = 'html': { 'head': {'title': 'My Page'}, 'body': { 'h1': 'Hello World', 'p': 'This is a Paragraph' } }

> b = render(a)

> console.log(b)

<html>
    <head>
        <title>My Page</title>
    </head>
    <body>
        <h1>Hello World</h1>
        <p>This is a Paragraph</p>
    </body>
</html>

恕我直言，与 parse() 相反

> c = parse(b)

{ 'html': {
    'head': {
        'title': 'My Page'
    }
    'body': {
        'h1': 'Hello World',
        'p': 'This is a Paragraph'
    }
}
于 2012-03-11T15:57:42.727 回答
3

+1 用于生成，但附加您正在生成的内容，即 GenerateSQL()

于 2008-09-29T18:06:30.280 回答
3

我投票支持“撰写”，但如果您不喜欢，我也建议“构建”

于 2008-09-29T19:22:39.550 回答
3

asSQL() 甚至更多 asQuery() 呢？

于 2011-05-27T15:20:55.003 回答
3

INHO Serialize、synthesize 都是不错的选择。另外，正如您命名为 parseQuery，我将使用 codeQuery

于 2012-05-10T04:44:21.720 回答
3

我通常使用“解析”作为转换方法，因此，我找不到与“转换”相反的词。（您不能“取消转换”某些东西，因为“取消转换”本身就是一种转换）。

这样想，最好的解决方案（对我来说）是有两个接收不同参数的“解析”方法。示例（Java）：

public class FooBarParser{

    public Foo parse(Bar bar);
    public Bar parse(Foo foo); 
}
于 2014-04-12T02:33:56.900 回答
2

去解析

deparse就是解析，为：

  • decompile就是编译
  • 分解是组合
  • 反序列化就是序列化
  • degroovy 是 groovy :) ;)

解析/解析不是结构的改变，而是转换。等效文本和抽象语法树格式之间的精确转换，保持所有关系和结构。

“组成”是指结构的变化，所以不太对。它建议从单独的独立部分组合（通常是第一次）。正如“分解”建议拆分成独立的部分一样。他们改变形式，而不仅仅是格式。

快速搜索显示该术语在以下范围内使用：

于 2013-11-01T00:28:54.657 回答
0

写查询。解析是从字符串中读取它并创建对象（假设是“实际”）表示的行为。相反的是将对象写入字符串。

于 2008-09-29T19:19:02.273 回答
0

.GetSqlQuery()将是我的选择

于 2011-04-15T03:00:22.397 回答
-6

我相信您正在寻找的答案是：“首先不要解析 SQL 或组装 SQL。使用对象/关系映射器并停止通过解决已经解决了很长时间的问题来浪费雇主的钱。 "

于 2009-10-20T20:46:33.053 回答