1

可能重复：
动态创建表的数据库设计

我需要在数据库中创建一个数据库。这个问题与此有关。我将尝试详细解释我正在尝试做的事情并提供代码示例。基本上，我希望能够在数据库中创建动态表。例如，我将有一个网页，允许用户使用列和数据创建自己的表。这是我想出的数据库设计：

aColumn
aDataType
aRow
aTable
zBit
zDateTime
zMoney
zNumber
zText

以 a 开头的表是z特定数据进入的数据，例如整数、日期时间值等。aColumn 是属于特定表的列。aRow 标识 aTable 中的特定行。这是数据库设计：

aTable: Id, name
aColumn: Id, Name, aTable, aDataType
aDataType: Id, Name
aRow: Id, aTable
zBit: Id, aRow, aColumn, Data(Bit)
zDateTime: Id, aRow, aColumn, Data (DateTime)
zMoney: Id, aRow, aColumn, Data (Money)
zNumber: Id, aRow, aColumn, Data (INT)
zText: Id, aRow, aColumn, Data (nvarchar(MAX))

这是我用来启动和运行它的一些示例数据：

一张桌子

Id          Name
1           Users

a列

Id          Name           aTable       aDataType
1           Name           1            2
2           UserId         1            1
3           Occupation     1            2

数据类型

Id          Name
1           Number
2           Text

一排

Id          aTable
1           1
2           1

一个号码

Id          aRow           aColumn      Data
1           1              1            1245
2           2              2            56

文本

Id          aRow           aColumn      Data
1           1              1            Sara
2           2              1            Jake

所有其他 z* 表为空白

这是创建动态表的查询：

select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zBit] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]
UNION ALL
select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zDateTime] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]
UNION ALL
select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zMoney] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]
UNION ALL
select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zMoney] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]
UNION ALL
select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zNumber] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]
UNION ALL
select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zText] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]

这是此查询的一部分：

select t.[Id] as [Table], c.Name as [Column], dt.Name as [DataType], r.[Id] as [Row], cast(v.Data as nvarchar(MAX)) as Data from [pod].[dbo].[aTable] t
INNER JOIN [pod].[dbo].[aColumn] c on t.Id = c.[aTable]
INNER JOIN [pod].[dbo].[aDataType] dt on c.[aDataType] = dt.Id
INNER JOIN [pod].[dbo].[aRow] r on t.[Id] = r.[aTable]
INNER JOIN [pod].[dbo].[zText] v on c.[Id] = v.aColumn and r.[Id] = v.[aRow]

正如您在此处看到的，一条数据（z* 表）由一行和一列标识。当我运行这个查询时，我得到这个：

结果

Table       Column         DataType     Row           Data
1           UserId         Number       1             1245          
1           UserId         Number       2             56
1           Name           Text         1             Sara
1           Name           Text         2             Jake

这是我想要的结果：（如果列未知，我不确定如何将这些行转换为列）

Row         UserId       Name
1           1245         Sara
2           56           Jake

大问题 该表假设有 3 列还记得吗？

a列

Id          Name           aTable       aDataType
1           Name           1            2
2           UserId         1            1
3           Occupation     1            2

所以我最终的预期结果是：

Row         UserId       Name         Occupation
1           1245         Sara         NULL
2           56           Jake         NULL

在结果中，我还需要对列进行排序。这甚至可能吗。哪些数据库支持这种功能。我对任何可以做到这一点的数据库都持开放态度。

4

2 回答 2

3

然后，您可能希望查看数据的实体属性值模型 (EAV)设计。

基本上，您可以拥有一个带有表名的表，以及表上的一些其他元数据。

然后，您可以为这些行中的每一行创建一个表以包含列数据，例如数据类型和名称。

然后，您有一个表格，您可以在其中将每列的值放在一个长表格中。

这允许您动态创建表，或动态添加/删除行。

有关关系和 EAV 的比较，您可以查看以下问题：

实体属性值数据库与严格的关系模型电子商务

但是，如果您想获得这些数据的关系视图，那么您将需要创建触发器来帮助使视图保持最新，这可能需要大量工作才能使其正常工作。如果您不需要关系视图，那么您应该没问题。

另一种方法是使用 NoSQL 数据库 ( http://en.wikipedia.org/wiki/NoSQL )，因为不必设置架构，因此您只需存储该行所需的列.

在这一点上，我会采用 NoSQL 方式，因为有许多数据库可以工作，而且你需要做的重新发明是最小的。

于 2012-08-26T15:50:26.003 回答
1

对于问题的最后一部分，您要问如何对 EAV 模式进行交叉表查询。一些数据库通过对 SQL 标准的扩展来支持这一点，而另一些则根本不支持。为了可移植性，您必须在您的应用程序中执行此操作。PostgreSQL为此在 tablefunc 扩展中提供了交叉表函数。

如果你走EAV的道路，你迟早会后悔的。它在某些有限的情况下很有用，但它不适合关系模型，并会导致很多痛苦和问题，其中最重要的是性能很差。

改为考虑：

  • 如果可能的话，重新设计，这样你就不需要动态模式。在您的情况下可能不可能，因为您的明确要求是基于 Web 的数据库应用程序的用户可编辑模式，但在大多数情况下，这是正确的选择。

  • ALTER TABLE使用,等动态创建/删除模式CREATE TABLE。一些数据库在这方面比其他数据库要好得多。PostgreSQL 的事务 DDL 可以提供很多帮助。需要小心以避免这成为性能和维护的噩梦，但如果您尝试使用动态结构对关系数据库进行建模，这可能是最明智的选择。

  • 针对类似 EAV 的查询进行了优化的键/值存储；请参阅键/值存储。请注意，这些系统中有许多不提供完整的 ACID 语义，并且可能具有有限的查询语言，因此您可以在应用程序中做更多的工作。

  • 在数据库中存储 XML 或 JSON。您可以使用关系数据库来做到这一点，但使用文档数据库可能会更好。适用与 K/V 商店相同的警告。如果您在应用程序中执行所有查询逻辑并且您的数据大小不太大，则此方法可以正常工作。

  • 在需要时使用PostgreSQL 等特定于数据库的功能hstore来支持任意键/值存储，并在不需要 k/v 的情况下使用标准关系设计。如果您希望将关系作为输出，它仍然是一个主要的 PITA，它涉及低效的交叉表查询和连接。

克里斯提出了一个很好的观点：你的整个设计非常可疑。请参阅：内部平台效应和TDWTF 对其的看法。说真的，不要去那里。

于 2012-08-27T02:00:17.373 回答