persistable-record 0.3.0.0 → 0.4.0.0

raw patch · 6 files changed

+14/−56 lines, 6 files

Files

persistable-record.cabal +1/−1
src/Database/Record.hs +2/−3
src/Database/Record/FromSql.hs +5/−6
src/Database/Record/Persistable.hs +0/−39
src/Database/Record/TH.hs +1/−0
src/Database/Record/ToSql.hs +5/−7

persistable-record.cabal view

@@ -1,5 +1,5 @@ name:                persistable-record-version:             0.3.0.0+version:             0.4.0.0 synopsis:            Binding between SQL database values and haskell records. description:         This package contiains types to represent table constraints and                      interfaces to bind between SQL database values and Haskell records.

src/Database/Record.hs view

@@ -40,13 +40,12 @@    deriveComposite, unique, derivedCompositePrimary, derivedUniqueConstraint) import Database.Record.Persistable   (PersistableSqlType, PersistableType(..), sqlNullValue,-   PersistableSqlValue, PersistableValue(..), fromSql, toSql,    PersistableRecordWidth, PersistableWidth(..), derivedWidth) import Database.Record.FromSql-  (RecordFromSql, FromSql(..), valueFromSql,+  (RecordFromSql, FromSql(..), valueRecordFromSql,    runTakeRecord, takeRecord, runToRecord, toRecord) import Database.Record.ToSql-  (ToSqlM, RecordToSql, ToSql(..), valueToSql,+  (ToSqlM, RecordToSql, ToSql(..), valueRecordToSql,    runFromRecord, wrapToSql, putRecord, putEmpty, fromRecord,    updateValuesByUnique, updateValuesByPrimary)

src/Database/Record/FromSql.hs view

@@ -26,11 +26,10 @@   FromSql (recordFromSql),   takeRecord, toRecord, -  valueFromSql+  valueRecordFromSql,   ) where -import Database.Record.Persistable-  (PersistableType, PersistableValue, persistableValue, toValue)+import Database.Record.Persistable (PersistableType) import qualified Database.Record.Persistable as Persistable import Database.Record.KeyConstraint   (HasColumnConstraint(columnConstraint), ColumnConstraint, NotNull, index)@@ -155,6 +154,6 @@ toRecord :: FromSql q a => [q] -> a toRecord =  runToRecord recordFromSql --- | Derived 'RecordFromSql' from persistable value.-valueFromSql :: PersistableValue q a => RecordFromSql q a-valueFromSql =  RecordFromSql $ \qs -> (toValue persistableValue $ head qs, tail qs)+-- | Derivation rule of 'RecordFromSql' proof object for value convert function.+valueRecordFromSql :: (q -> a) -> RecordFromSql q a+valueRecordFromSql d = createRecordFromSql $ \qs -> (d $ head qs, tail qs)

src/Database/Record/Persistable.hs view

@@ -20,14 +20,9 @@   PersistableRecordWidth, runPersistableRecordWidth,   unsafePersistableRecordWidth, unsafeValueWidth, (<&>), maybeWidth, -  -- * Bidirectional conversion between single column type and SQL type-  PersistableSqlValue, persistableSqlValue,-  toValue, fromValue,-   -- * Inference rules for proof objects    PersistableType(..), sqlNullValue,-  PersistableValue (..), fromSql, toSql,   PersistableWidth (..), derivedWidth   ) where @@ -45,26 +40,6 @@ unsafePersistableSqlTypeFromNull =  PersistableSqlType  --- | Proof object to specify value type 'a' is convertible with SQL type 'q'-data PersistableSqlValue q a = PersistableSqlValue (q -> a) (a -> q)---- | Run 'PersistableSqlValue' proof object. Convert from SQL type 'q' into Haskell type 'a'.-toValue :: PersistableSqlValue q a -- ^ Proof object which has capability to convert-        -> q                       -- ^ SQL type-        -> a                       -- ^ Haskell type-toValue   (PersistableSqlValue f _) = f---- | Run 'PersistableSqlValue' proof object. Convert from Haskell type 'a' into SQL type 'q'.-fromValue :: PersistableSqlValue q a -- ^ Proof object which has capability to convert-          -> a                       -- ^ Haskell type-          -> q                       -- ^ SQL type-fromValue (PersistableSqlValue _ g) = g---- | Axiom of 'PersistableSqlValue' for SQL type 'q' and Haskell type 'a'.-persistableSqlValue :: PersistableSqlType q -> (q -> a) -> (a -> q) -> PersistableSqlValue q a-persistableSqlValue =  const PersistableSqlValue-- -- | Proof object to specify width of Haskell type 'a' --   when converting to SQL type list. newtype PersistableRecordWidth a =@@ -125,17 +100,3 @@ derivedWidth :: PersistableWidth a => (PersistableRecordWidth a, Int) derivedWidth =  (pw, runPersistableRecordWidth pw) where   pw = persistableWidth----- | Interface of inference rule for 'PersistableSqlValue' proof object-class PersistableType q => PersistableValue q a where-  -- | Infer 'PersistableSqlValue' proof object.-  persistableValue :: PersistableSqlValue q a---- | Run inferred 'PersistableSqlValue' proof object. Convert from SQL type 'q' into Haskell type 'a'.-fromSql :: PersistableValue q a => q -> a-fromSql =  toValue persistableValue---- | Run inferred 'PersistableSqlValue' proof object. Convert from Haskell type 'a' into SQL type 'q'.-toSql :: PersistableValue q a => a -> q-toSql =  fromValue persistableValue

src/Database/Record/TH.hs view

@@ -231,6 +231,7 @@ columnDefault :: String -> TypeQ -> (VarName, TypeQ) columnDefault n t = (varCamelcaseName n, t) +-- | Record type declaration template with configured names. defineRecordTypeWithConfig :: NameConfig -> String -> String -> [(String, TypeQ)] -> [Name] -> Q [Dec] defineRecordTypeWithConfig config schema table columns =   defineRecordType

src/Database/Record/ToSql.hs view

@@ -24,7 +24,7 @@   ToSql (recordToSql),   putRecord, putEmpty, fromRecord, wrapToSql, -  valueToSql,+  valueRecordToSql,    -- * Make parameter list for updating with key   updateValuesByUnique',@@ -37,15 +37,13 @@  import Data.Array (listArray, (!)) import Data.Set (toList, fromList, (\\))-import Control.Applicative (pure) import Control.Monad.Trans.Writer (Writer, execWriter, tell) import Data.DList (DList) import qualified Data.DList as DList  import Database.Record.Persistable   (PersistableSqlType, runPersistableNullValue, PersistableType (persistableType),-   PersistableRecordWidth, runPersistableRecordWidth, PersistableWidth(persistableWidth),-   PersistableValue, persistableValue, fromValue)+   PersistableRecordWidth, runPersistableRecordWidth, PersistableWidth(persistableWidth)) import Database.Record.KeyConstraint   (Primary, Unique, KeyConstraint, HasKeyConstraint(keyConstraint), unique, indexes) @@ -126,9 +124,9 @@ fromRecord :: ToSql q a => a -> [q] fromRecord =  runToSqlM . putRecord --- | Derived 'RecordToSql' from persistable value.-valueToSql :: PersistableValue q a => RecordToSql q a-valueToSql =  RecordToSql $ tell . pure . fromValue persistableValue+-- | Derivation rule of 'RecordToSql' proof object for value convert function.+valueRecordToSql :: (a -> q) -> RecordToSql q a+valueRecordToSql = createRecordToSql . ((:[]) .)  -- | Make untyped indexes to update column from key indexes and record width. --   Expected by update form like