图数据库中时间序列数据的序列聚合

Question

全部，

我是图形数据库领域的新手，想知道这种类型的示例是否适用于图形数据库。

假设我正在看一场棒球比赛。当每个球员去击球时，有 3 种可能的结果：击球、三振或步行。

对于每个击球手和整个棒球赛季，我想弄清楚的是序列的计数。

例如，对于上板 n 次的击球手，有多少人具有特定的顺序（例如，击球/步行/三振出局或击球/击球/击球/击球），如果是，有多少相同的顺序击球手重复按时间索引的相同顺序。为了进一步解释，时间会让我知道某个特定的序列（例如击球/步行/三振出局或击球/击球/击球/击球）是否发生在赛季开始、中期或下半年。

对于键值类型数据库，原始数据如下所示：

Batter      Time        Game    Event       Bat
-------     -----       ----    ---------   ---
Charles     April       1       Hit         1
Charles     April       1       strikeout   2
Charles     April       1       Walk        3
Doug        April       1       Walk        1
Doug        April       1       Hit         2
Doug        April       1       strikeout   3
Charles     April       2       strikeout   1
Charles     April       2       strikeout   2
Doug        May         5       Hit         1
Doug        May         5       Hit         2
Doug        May         5       Hit         3
Doug        May         5       Hit         4

因此，我的输出将如下所示：

Sequence                    Freq        Unique Batters  Time
-----------------------     ----        --------------  ------
hit                         5000        600             April
walk/strikeout              3000        350             April
strikeout/strikeout/hit     2000        175             April
hit/hit/hit/hit/hit         1000        80              April
hit                         6000        800             May
walk/strikeout              3500        425             May
strikeout/strikeout/hit     2750        225             May
hit/hit/hit/hit/hit         1250        120             May
.                           .           .               .
.                           .           .               .
.                           .           .               .
.                           .           .               .

如果这对于图形数据库是可行的，它是否也可以扩展？如果击球手不是 3 个可能的结果，而是 10,000,000 名击球手有 10,000 个潜在结果怎么办？

更重要的是，10,000 个独特的结果将在组合设置中排序（例如 10,000 CHOOSE 2、10,000 CHOOSE 3 等）。

那么我的问题是，如果图形数据库是合适的，您会如何建议设置解决方案？

提前非常感谢。

Answer 1

自从提出这个问题以来，图形数据库已经取得了长足的进步，但这个问题的答案是，绝对是的，图形数据库可用于查找击球手的表现模式。

免责声明：我是 Objectivity, Inc. 的现场运营总监。

这不是产品插件。这个问题可以在市场上的许多产品中得到解决。您特别提到了扩大问题规模，这很可能是某些产品的限制因素。

为了解决这个问题，我使用了 Objectivity/DB 数据库，它是一个可大规模扩展的对象/图形数据库，具有一种功能齐全的图形导航查询语言，称为 DO 用于声明性客观性。

这是我用来解决问题的架构：

CREATE CLASS Season  {
    year                : Integer,      
    games               : List { Element: Reference { referenced: Game }, CollectionTypeName: TreeListOfReferences }        
}

CREATE CLASS Game {
    date                : DateTime,
    homeTeam            : Reference { referenced: Team, inverse: homeGames },
    awayTeam            : Reference { referenced: Team, inverse: awayGames },
    from                : Reference { referenced: Season, inverse: games },
    innings             : Reference { referenced: Inning, inverse: game }
}

CREATE CLASS Inning {
    number              : Integer,
    game                : Reference { referenced: Game, inverse: innings },
    batters             : Reference { referenced: AtBat, inverse: inning }
}

CREATE CLASS AtBat {
    result              : String,
    inning              : Reference { referenced: Inning, inverse: batters },
    batter              : Reference { referenced: Player, inverse: atBats },
    nextAtBat           : Reference { referenced: AtBat, inverse: prevAtBat },
    prevAtBat           : Reference { referenced: AtBat, inverse: nextAtBat },
    nextBatter          : Reference { referenced: AtBat, inverse: prevBatter },
    prevBatter          : Reference { referenced: AtBat, inverse: nextBatter }
}

CREATE CLASS Player {
    name                : String,
    teams               : List { Element: Reference { EdgeClass: PlayedFor, EdgeAttribute: team }, CollectionTypeName: TreeListOfReferences },
    atBats              : List { Element: Reference { referenced: AtBat, inverse: batter }, CollectionTypeName: TreeListOfReferences }
}

CREATE CLASS PlayedFor {
    player              : Reference { referenced: Player, inverse: teams },
    team                : Reference { referenced: Team, inverse: players },
    start               : DateTime,
    end                 : DateTime
}

CREATE CLASS Team {
    name                : String,
    homeGames           : Reference { referenced: Game, inverse: homeTeam },
    awayGames           : Reference { referenced: Game, inverse: awayTeam },        
    players             : List { Element: Reference { EdgeClass: PlayedFor, EdgeAttribute: team }, CollectionTypeName: TreeListOfReferences }
}   

这里是架构的摘要。每个玩家都连接到他们自己的每个 AtBat 对象。每个玩家的 AtBat 对象以双向链表的形式存在。每个 AtBat 对象都指向拥有它的玩家。

示例数据集可能如下所示：

这个想法是找到一个用户定义的 AtBat 对象序列，然后找到拥有该序列的玩家。在下面的查询中，我们正在寻找“Strike Out”、“Hit”和“Strike Out”模式。当我们找到该模式时，我们需要知道与该模式关联的 Player。因为所有 AtBat 对象都链接回拥有的 Player，所以我们在查询中要做的就是表达我们想要的 AtBat 对象序列，然后从最后一个 AtBat 对象导航到它所连接的 Player 对象。查询如下：

match path = (a1:AtBat {result == "Strike Out"})
           -[:nextAtBat]->(a2:AtBat {result == "Hit"})
           -[:nextAtBat]->(a3:AtBat {result == "Strike Out"})
           -->(p:Player) 
           group by p.name
           return a1.result, a2.result, a3.result, p.name;

结果示例如下所示：

{
  _Projection
  {
    a1.result:'Strike Out',
    a2.result:'Hit',
    a3.result:'Strike Out',
    p.name:'Player0_TeamA'
  },
  _Projection
  {
    a1.result:'Strike Out',
    a2.result:'Hit',
    a3.result:'Strike Out',
    p.name:'Player0_TeamB'
  },
  _Projection
  {
    a1.result:'Strike Out',
    a2.result:'Hit',
    a3.result:'Strike Out',
    p.name:'Player10_TeamA'
  },

此图像描述了查找模式，然后从最后一个 AtBat 导航到关联的播放器：