database - que - ¿Qué marco ORM puede manejar mejor un diseño de base de datos MVCC?

entity framework que es

Question

Al diseñar una base de datos para usar MVCC (Control de Concurrencia de Varias Versiones), usted crea tablas con un campo booleano como "IsLatest" o un entero "VersionId", y nunca hace ninguna actualización, solo inserta nuevos registros cuando cambian las cosas.

MVCC le ofrece auditoría automática para aplicaciones que requieren un historial detallado, y también alivia la presión sobre la base de datos con respecto a los bloqueos de actualización. Las desventajas son que hace que su tamaño de datos sea mucho más grande y ralentiza las selecciones, debido a la cláusula adicional necesaria para obtener la última versión. También hace que las claves foráneas sean más complicadas.

(Tenga en cuenta que no estoy hablando de la compatibilidad con MVCC nativa en RDBMS, como el nivel de aislamiento de instantáneas de SQL Server)

Esto se ha discutido en otras publicaciones aquí en Stack Overflow. [todo - enlaces]

Me pregunto, ¿cuál de los marcos de entidad / ORM prevalentes (Linq a Sql, ADO.NET EF, Hibernate, etc.) puede respaldar este tipo de diseño? Este es un cambio importante en el patrón de diseño de ActiveRecord típico, por lo que no estoy seguro de si la mayoría de las herramientas que existen podrían ayudar a alguien que decida ir por esta ruta con su modelo de datos. Estoy particularmente interesado en cómo se manejarán las claves externas, porque ni siquiera estoy seguro de la mejor manera de modelar los datos para admitir MVCC.

Answer 1

A mi leal saber y entender, los marcos ORM van a querer generar el código CRUD para usted, por lo que deberían estar explícitamente diseñados para implementar una opción MVCC; No conozco ninguno que lo haga de la caja.

Desde el punto de vista de un marco de Entity, CSLA no implementa la persistencia para usted en absoluto; solo define una interfaz de "Adaptador de datos" que utiliza para implementar cualquier persistencia que necesite. De modo que podría configurar plantillas de generación de código (CodeSmith, etc.) para generar automáticamente la lógica CRUD para sus entidades CSLA que vayan junto con una arquitectura de base de datos MVCC.

Este enfoque funcionaría con cualquier marco de entidad, muy probablemente, no solo CSLA, sino que sería una implementación muy "limpia" en CSLA.

Answer 2

Podría considerar implementar el nivel de MVCC puramente en el DB, usando procesos y vistas almacenados para manejar mis operaciones de datos. Luego, podría presentar una API razonable para cualquier ORM que fuera capaz de mapear desde y hacia procs almacenados, y podría dejar que la DB se ocupe de los problemas de integridad de los datos (ya que se trata de una compilación para eso). Si fue por este camino, es posible que desee ver una solución de mapas más pura como IBatis o IBatis.net.

Answer 3

Diseñé una base de datos de manera similar (solo INSERTs - no UPDATEs, no DELETE).

Casi todas mis consultas SELECT estaban en contra de vistas de solo las filas actuales para cada tabla (número de revisión más alto).

Las vistas se veían así ...

SELECT
dbo.tblBook.BookId,
dbo.tblBook.RevisionId,
dbo.tblBook.Title,
dbo.tblBook.AuthorId,
dbo.tblBook.Price,
dbo.tblBook.Deleted
FROM
dbo.tblBook INNER JOIN
(
SELECT
BookId,
MAX(RevisionId) AS RevisionId
FROM
dbo.tblBook
GROUP BY
BookId
) AS CurrentBookRevision ON
dbo.tblBook.BookId = CurrentBookRevision.BookId AND
dbo.tblBook.RevisionId = CurrentBookRevision.RevisionId
WHERE
dbo.tblBook.Deleted = 0

Y mis insertos (y actualizaciones y eliminaciones) fueron manejados por procedimientos almacenados (uno por tabla).

Los procedimientos almacenados se veían así ...

ALTER procedure [dbo].[sp_Book_CreateUpdateDelete]
@BookId uniqueidentifier,
@RevisionId bigint,
@Title varchar(256),
@AuthorId uniqueidentifier,
@Price smallmoney,
@Deleted bit
as
insert into tblBook
(
BookId,
RevisionId,
Title,
AuthorId,
Price,
Deleted
)
values
(
@BookId,
@RevisionId,
@Title,
@AuthorId,
@Price,
@Deleted
)

Los números de revisión se manejaron por transacción en el código de Visual Basic ...

Shared Sub Save(ByVal UserId As Guid, ByVal Explanation As String, ByVal Commands As Collections.Generic.Queue(Of SqlCommand))
Dim Connection As SqlConnection = New SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings("Connection").ConnectionString)
Connection.Open()
Dim Transaction As SqlTransaction = Connection.BeginTransaction
Try
Dim RevisionId As Integer = Nothing
Dim RevisionCommand As SqlCommand = New SqlCommand("sp_Revision_Create", Connection)
RevisionCommand.CommandType = CommandType.StoredProcedure
RevisionCommand.Parameters.AddWithValue("@RevisionId", 0)
RevisionCommand.Parameters(0).SqlDbType = SqlDbType.BigInt
RevisionCommand.Parameters(0).Direction = ParameterDirection.Output
RevisionCommand.Parameters.AddWithValue("@UserId", UserId)
RevisionCommand.Parameters.AddWithValue("@Explanation", Explanation)
RevisionCommand.Transaction = Transaction
LogDatabaseActivity(RevisionCommand)
If RevisionCommand.ExecuteNonQuery() = 1 Then ''rows inserted
RevisionId = CInt(RevisionCommand.Parameters(0).Value) ''generated key
Else
Throw New Exception("Zero rows affected.")
End If
For Each Command As SqlCommand In Commands
Command.Connection = Connection
Command.Transaction = Transaction
Command.CommandType = CommandType.StoredProcedure
Command.Parameters.AddWithValue("@RevisionId", RevisionId)
LogDatabaseActivity(Command)
If Command.ExecuteNonQuery() < 1 Then ''rows inserted
Throw New Exception("Zero rows affected.")
End If
Next
Transaction.Commit()
Catch ex As Exception
Transaction.Rollback()
Throw New Exception("Rolled back transaction", ex)
Finally
Connection.Close()
End Try
End Sub

Creé un objeto para cada tabla, cada uno con constructores, propiedades y métodos de instancia, comandos de crear-actualizar-eliminar, un conjunto de funciones de búsqueda y funciones de clasificación IComparable. Fue una gran cantidad de código.

Tabla de BD uno a uno para el objeto VB ...

Public Class Book
Implements iComparable
#Region " Constructors "
Private _BookId As Guid
Private _RevisionId As Integer
Private _Title As String
Private _AuthorId As Guid
Private _Price As Decimal
Private _Deleted As Boolean
...
Sub New(ByVal BookRow As DataRow)
Try
_BookId = New Guid(BookRow("BookId").ToString)
_RevisionId = CInt(BookRow("RevisionId"))
_Title = CStr(BookRow("Title"))
_AuthorId = New Guid(BookRow("AuthorId").ToString)
_Price = CDec(BookRow("Price"))
Catch ex As Exception
''TO DO: log exception
Throw New Exception("DataRow does not contain valid Book data.", ex)
End Try
End Sub
#End Region
...
#Region " Create, Update & Delete "
Function Save() As SqlCommand
If _BookId = Guid.Empty Then
_BookId = Guid.NewGuid()
End If
Dim Command As SqlCommand = New SqlCommand("sp_Book_CreateUpdateDelete")
Command.Parameters.AddWithValue("@BookId", _BookId)
Command.Parameters.AddWithValue("@Title", _Title)
Command.Parameters.AddWithValue("@AuthorId", _AuthorId)
Command.Parameters.AddWithValue("@Price", _Price)
Command.Parameters.AddWithValue("@Deleted", _Deleted)
Return Command
End Function
Shared Function Delete(ByVal BookId As Guid) As SqlCommand
Dim Doomed As Book = FindByBookId(BookId)
Doomed.Deleted = True
Return Doomed.Save()
End Function
...
#End Region
...
#Region " Finders "
Shared Function FindByBookId(ByVal BookId As Guid, Optional ByVal TryDeleted As Boolean = False) As Book
Dim Command As SqlCommand
If TryDeleted Then
Command = New SqlCommand("sp_Book_FindByBookIdTryDeleted")
Else
Command = New SqlCommand("sp_Book_FindByBookId")
End If
Command.Parameters.AddWithValue("@BookId", BookId)
If Database.Find(Command).Rows.Count > 0 Then
Return New Book(Database.Find(Command).Rows(0))
Else
Return Nothing
End If
End Function

Tal sistema preserva todas las versiones pasadas de cada fila, pero puede ser un verdadero dolor para administrar.

PROS:

• Historia total preservada
• Menos procedimientos almacenados

CONTRAS:

• se basa en la aplicación de bases de datos para la integridad de datos
• gran cantidad de código para ser escrito
• No se administraron claves externas dentro de la base de datos (adiós a la generación automática de objetos estilo Linq-to-SQL)
• Todavía no se me ocurrió una buena interfaz de usuario para recuperar todo lo preservado en el pasado.

CONCLUSIÓN:

• No me tomaría tantas molestias en un nuevo proyecto sin una solución ORM lista para usar fácil de usar.

Tengo curiosidad si Microsoft Entity Framework puede manejar bien esos diseños de bases de datos.

Jeff y el resto del equipo de deben haber tenido que lidiar con problemas similares al desarrollar : las revisiones anteriores de las preguntas y respuestas editadas se guardan y recuperan.

Creo que Jeff ha declarado que su equipo usó Linq para SQL y MS SQL Server.

Me pregunto cómo manejaron estos problemas.

Answer 4

Siempre pensé que utilizarías un desencadenador db en la actualización y eliminaría esas filas en una tabla TableName_Audit.

Eso funcionaría con los ORM, le daría su historial y no reduciría el rendimiento de selección en esa tabla. ¿Es una buena idea o me estoy perdiendo algo?

Answer 5

Echa un vistazo al proyecto Envers: funciona bien con las aplicaciones JPA / Hibernate y básicamente lo hace por ti: realiza un seguimiento de las diferentes versiones de cada Entity en otra tabla y te brinda posibilidades similares a SVN ("Dame la versión de Person que se usa 2008-11 -05 ... ")

http://www.jboss.org/envers/

/ Jens

Answer 6

Lo que hacemos, es usar un ORM (hibernación) normal y manejar el MVCC con vistas + en lugar de desencadenantes.

Entonces, hay una vista v_emp, que simplemente se ve como una tabla normal, puede insertarla y actualizarla bien, sin embargo, cuando hace esto, los desencadenantes se encargan de insertar los datos correctos en la tabla base.

No ... Odio este método :) Iría con una API de procedimiento almacenado como lo sugiere Tim.