relational-schemas-0.1.7.0/0000755000000000000000000000000013466565435013637 5ustar0000000000000000relational-schemas-0.1.7.0/Setup.hs0000644000000000000000000000005613466565435015274 0ustar0000000000000000import Distribution.Simple main = defaultMain relational-schemas-0.1.7.0/ChangeLog.md0000644000000000000000000000175513466565435016020 0ustar0000000000000000 ## 0.1.7.0 - adjust sub-directory modules of each DBMS to top module name. - enable addModifyTableAliasAS flag of SQLite3 configuration. - add custom API modules for each DBMS with appropriate configuration. ## 0.1.6.2 - update tested-with. ## 0.1.6.1 - update version constraint. ( along with re-versioned relational-query. ) ## 0.1.6.0 - apply projections with overloaded-labels to schema tables. ## 0.1.5.0 - apply relational-query-0.10.0 ## 0.1.4.1 - apply relational-query-0.9.5 ## 0.1.4.0 - add tested-with 8.2.1. - switch 3rd number of version to separate from no-generic version. ## 0.1.3.3 - Use Haskell implementation test instead of flag test in .cabal ## 0.1.3.2 - Apply generic instances to schema queries. - Drop unused implicit imports. ## 0.1.3.1 - Add tested-with. ## 0.1.3.0 - Update typeMap of SQLite3 schema. ## 0.1.2.0 - Get type info of network address in PostgreSQL schema. ## 0.1.1.0 - Add medium-int to typeMap of MySQL schema. relational-schemas-0.1.7.0/LICENSE0000644000000000000000000000275613466565435014656 0ustar0000000000000000Copyright (c) 2013, Kei Hibino All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Kei Hibino nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. relational-schemas-0.1.7.0/relational-schemas.cabal0000644000000000000000000001354513466565435020406 0ustar0000000000000000name: relational-schemas version: 0.1.7.0 synopsis: RDBMSs' schema templates for relational-query description: This package contains some RDBMSs' schema structure definitions. . Supported RDBMS schemas are below: . - IBM DB2 - PostgreSQL - Microsoft SQLServer - SQLite3 - Oracle - MySQL homepage: http://khibino.github.io/haskell-relational-record/ license: BSD3 license-file: LICENSE author: Kei Hibino, Shohei Murayama, Shohei Yasutake, Sho KURODA maintainer: ex8k.hibino@gmail.com, shohei.murayama@gmail.com, amutake.s@gmail.com, krdlab@gmail.com copyright: Copyright (c) 2013-2019 Kei Hibino, 2013 Shohei Murayama, 2013 Shohei Yasutake, 2013 Sho KURODA category: Database build-type: Simple cabal-version: >=1.10 tested-with: GHC == 8.6.1, GHC == 8.6.2, GHC == 8.6.3, GHC == 8.6.4, GHC == 8.6.5 , GHC == 8.4.1, GHC == 8.4.2, GHC == 8.4.3, GHC == 8.4.4 , GHC == 8.2.1, GHC == 8.2.2 , GHC == 8.0.1, GHC == 8.0.2 , GHC == 7.10.1, GHC == 7.10.2, GHC == 7.10.3 , GHC == 7.8.1, GHC == 7.8.2, GHC == 7.8.3, GHC == 7.8.4 , GHC == 7.6.1, GHC == 7.6.2, GHC == 7.6.3 , GHC == 7.4.1, GHC == 7.4.2 extra-source-files: ChangeLog.md library exposed-modules: Database.Relational.Schema.DB2Syscat.Columns Database.Relational.Schema.IBMDB2.Columns Database.Relational.Schema.IBMDB2 Database.Relational.Schema.PgCatalog.PgAttribute Database.Relational.Schema.PgCatalog.PgType Database.Relational.Schema.PostgreSQL.PgAttribute Database.Relational.Schema.PostgreSQL.PgType Database.Relational.Schema.PostgreSQL Database.Relational.Schema.SQLServerSyscat.Columns Database.Relational.Schema.SQLServerSyscat.Types Database.Relational.Schema.SQLServer.Columns Database.Relational.Schema.SQLServer.Types Database.Relational.Schema.SQLServer Database.Relational.Schema.SQLite3Syscat.IndexInfo Database.Relational.Schema.SQLite3Syscat.IndexList Database.Relational.Schema.SQLite3Syscat.TableInfo Database.Relational.Schema.SQLite3.IndexInfo Database.Relational.Schema.SQLite3.IndexList Database.Relational.Schema.SQLite3.TableInfo Database.Relational.Schema.SQLite3 Database.Relational.Schema.OracleDataDictionary.TabColumns Database.Relational.Schema.Oracle.TabColumns Database.Relational.Schema.Oracle Database.Relational.Schema.MySQLInfo.Columns Database.Relational.Schema.MySQL.Columns Database.Relational.Schema.MySQL Database.Relational.Schema.DB2Syscat.Config Database.Relational.Schema.PgCatalog.Config Database.Relational.Schema.SQLServerSyscat.Config Database.Relational.Schema.SQLite3Syscat.Config Database.Relational.Schema.OracleDataDictionary.Config Database.Relational.Schema.MySQLInfo.Config Database.Custom.IBMDB2 Database.Custom.PostgreSQL Database.Custom.SQLServer Database.Custom.SQLite3 Database.Custom.Oracle Database.Custom.MySQL other-modules: Database.Relational.Schema.IBMDB2.Config Database.Relational.Schema.IBMDB2.Tabconst Database.Relational.Schema.IBMDB2.Keycoluse Database.Relational.Schema.PostgreSQL.Config Database.Relational.Schema.PostgreSQL.PgConstraint Database.Relational.Schema.PostgreSQL.PgNamespace Database.Relational.Schema.PostgreSQL.PgClass Database.Relational.Schema.SQLServer.Config Database.Relational.Schema.SQLServer.IndexColumns Database.Relational.Schema.SQLServer.Indexes Database.Relational.Schema.SQLite3.Config Database.Relational.Schema.Oracle.Config Database.Relational.Schema.Oracle.ConsColumns Database.Relational.Schema.Oracle.Constraints Database.Relational.Schema.MySQL.Config Database.Relational.Schema.MySQL.KeyColumnUsage Database.Relational.Schema.MySQL.TableConstraints build-depends: base <5 , template-haskell , containers , time , bytestring , relational-query >= 0.12.2 if impl(ghc == 7.4.*) build-depends: ghc-prim == 0.2.* hs-source-dirs: src ghc-options: -Wall if impl(ghc >= 8) ghc-options: -Wcompat -Wnoncanonical-monadfail-instances default-language: Haskell2010 source-repository head type: git location: https://github.com/khibino/haskell-relational-record source-repository head type: mercurial location: https://bitbucket.org/khibino/haskell-relational-record relational-schemas-0.1.7.0/src/0000755000000000000000000000000013466565435014426 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/0000755000000000000000000000000013466565435016132 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/0000755000000000000000000000000013466565435020224 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/0000755000000000000000000000000013466565435021424 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQL.hs0000644000000000000000000001114113466565435022723 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} module Database.Relational.Schema.MySQL ( module Database.Relational.Schema.MySQL.Config , normalizeColumn , notNull , getType , columnsQuerySQL , primaryKeyQuerySQL ) where import Data.Int (Int8, Int16, Int32, Int64) import Data.Char (toLower, toUpper) import Data.Map (Map, fromList) import qualified Data.Map as Map import Data.Time (Day, LocalTime, TimeOfDay) import Data.Time.Clock.POSIX (POSIXTime) import Data.ByteString (ByteString) import Control.Applicative ((<|>)) import Language.Haskell.TH (TypeQ) import Database.Relational ( Query , relationalQuery , query , relation' , wheres , (.=.) , (!) , (><) , placeholder , asc , value ) import Database.Relational.Schema.MySQL.Config import Database.Relational.Schema.MySQL.Columns (Columns, columns) import qualified Database.Relational.Schema.MySQL.Columns as Columns import Database.Relational.Schema.MySQL.TableConstraints (tableConstraints) import qualified Database.Relational.Schema.MySQL.TableConstraints as Tabconst import Database.Relational.Schema.MySQL.KeyColumnUsage (keyColumnUsage) import qualified Database.Relational.Schema.MySQL.KeyColumnUsage as Keycoluse -- TODO: Need to check unsigned int types to avoid wrong mapping mapFromSqlDefault :: Map String TypeQ mapFromSqlDefault = fromList [ ("CHAR", [t| String |]) , ("VARCHAR", [t| String |]) , ("TINYTEXT", [t| String |]) , ("TEXT", [t| String |]) , ("MEDIUMTEXT", [t| String |]) , ("LONGTEXT", [t| String |]) , ("TINYBLOB", [t| ByteString |]) , ("BLOB", [t| ByteString |]) , ("MEDIUMBLOB", [t| ByteString |]) , ("LONGBLOB", [t| ByteString |]) , ("DATE", [t| Day |]) , ("DATETIME", [t| LocalTime |]) , ("TIME", [t| TimeOfDay |]) , ("TIMESTAMP", [t| POSIXTime |]) , ("TINYINT", [t| Int8 |]) , ("SMALLINT", [t| Int16 |]) , ("MEDIUMINT", [t| Int32 |]) , ("INT", [t| Int32 |]) , ("INTEGER", [t| Int32 |]) , ("BIGINT", [t| Int64 |]) ] normalizeColumn :: String -> String normalizeColumn = map toLower notNull :: Columns -> Bool notNull = (== "NO") . Columns.isNullable getType :: Map String TypeQ -> Columns -> Maybe (String, TypeQ) getType mapFromSql rec = do typ <- Map.lookup key mapFromSql <|> Map.lookup key mapFromSqlDefault return (normalizeColumn $ Columns.columnName rec, mayNull typ) where key = map toUpper $ Columns.dataType rec mayNull typ = if notNull rec then typ else [t|Maybe $(typ)|] columnsQuerySQL :: Query (String, String) Columns columnsQuerySQL = relationalQuery columnsRelationFromTable where columnsRelationFromTable = relation' $ do c <- query columns (schemaP, ()) <- placeholder (\ph -> wheres $ c ! Columns.tableSchema' .=. ph) (nameP , ()) <- placeholder (\ph -> wheres $ c ! Columns.tableName' .=. ph) asc $ c ! Columns.ordinalPosition' return (schemaP >< nameP, c) primaryKeyQuerySQL :: Query (String, String) String primaryKeyQuerySQL = relationalQuery primaryKeyRelation where primaryKeyRelation = relation' $ do cons <- query tableConstraints key <- query keyColumnUsage wheres $ cons ! Tabconst.tableSchema' .=. key ! Keycoluse.tableSchema' wheres $ cons ! Tabconst.tableName' .=. key ! Keycoluse.tableName' wheres $ cons ! Tabconst.constraintName' .=. key ! Keycoluse.constraintName' (schemaP, ()) <- placeholder (\ph -> wheres $ cons ! Tabconst.tableSchema' .=. ph) (nameP , ()) <- placeholder (\ph -> wheres $ cons ! Tabconst.tableName' .=. ph) wheres $ cons ! Tabconst.constraintType' .=. value "PRIMARY KEY" asc $ key ! Keycoluse.ordinalPosition' return (schemaP >< nameP, key ! Keycoluse.columnName') relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3.hs0000644000000000000000000000647413466565435023217 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} module Database.Relational.Schema.SQLite3 ( module Database.Relational.Schema.SQLite3.Config, getType, normalizeColumn, normalizeType, notNull, tableInfoQuerySQL, indexListQuerySQL, indexInfoQuerySQL ) where import qualified Data.Map as Map import qualified Database.Relational.Schema.SQLite3.TableInfo as TableInfo import Language.Haskell.TH (TypeQ) import Control.Arrow (first) import Control.Applicative ((<|>)) import Data.ByteString (ByteString) import Data.Char (toLower, toUpper) import Data.Int (Int8, Int16, Int32, Int64) import Data.Map (Map) import Data.Time (Day, LocalTime) import Database.Relational (Query, unsafeTypedQuery) import Database.Relational.Schema.SQLite3.Config import Database.Relational.Schema.SQLite3.IndexInfo import Database.Relational.Schema.SQLite3.IndexList import Database.Relational.Schema.SQLite3.TableInfo --{-# ANN module "HLint: ignore Redundant $" #-} -- -- SQLite3 is dynamic typing, -- so assign narrower constraints in this default mapping. -- Using upper case typenames along with SQLite3 document. mapFromSqlDefault :: Map String TypeQ mapFromSqlDefault = Map.fromList [ ("INT", [t|Int32|]) , ("INTEGER", [t|Int32|]) , ("TINYINT", [t|Int8|]) , ("SMALLINT", [t|Int16|]) , ("MEDIUMINT", [t|Int32|]) , ("BIGINT", [t|Int64|]) , ("INT2", [t|Int16|]) , ("INT8", [t|Int64|]) , ("CHARACTER", [t|String|]) , ("VARCHAR", [t|String|]) , ("TEXT", [t|String|]) , ("BLOB", [t|ByteString|]) , ("REAL", [t|Double|]) , ("DOUBLE", [t|Double|]) , ("FLOAT", [t|Float|]) , ("DATE", [t|Day|]) , ("DATETIME", [t|LocalTime|]) ] normalizeColumn :: String -> String normalizeColumn = map toLower normalizeType :: String -> String normalizeType = map toUpper . takeWhile (not . flip elem " (") notNull :: TableInfo -> Bool notNull info = isTrue . TableInfo.notnull $ info where isTrue 0 = False isTrue _ = True -- for backward compatibility normalizeMap :: Map String TypeQ -> Map String TypeQ normalizeMap = Map.fromList . map (first $ map toUpper) . Map.toList getType :: Map String TypeQ -> TableInfo -> Maybe (String, TypeQ) getType mapFromSql info = do typ <- Map.lookup key (normalizeMap {- for backward compatibility -} mapFromSql) <|> Map.lookup key mapFromSqlDefault return (normalizeColumn (TableInfo.name info), mayNull typ) where key = normalizeType . TableInfo.ctype $ info mayNull typ = if notNull info then typ else [t|Maybe $(typ)|] tableInfoQuerySQL :: String -> String -> Query () TableInfo tableInfoQuerySQL db tbl = unsafeTypedQuery $ "pragma " ++ db ++ ".table_info(" ++ tbl ++ ");" indexListQuerySQL :: String -> String -> Query () IndexList indexListQuerySQL db tbl = unsafeTypedQuery $ "pragma " ++ db ++ ".index_list(" ++ tbl ++ ");" indexInfoQuerySQL :: String -> String -> Query () IndexInfo indexInfoQuerySQL db idx = unsafeTypedQuery $ "pragma " ++ db ++ ".index_info(" ++ idx ++ ");" relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer.hs0000644000000000000000000001223413466565435023610 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} module Database.Relational.Schema.SQLServer ( module Database.Relational.Schema.SQLServer.Config, getType, normalizeColumn, notNull, columnTypeQuerySQL, primaryKeyQuerySQL ) where import qualified Data.Map as Map import qualified Database.Relational.Schema.SQLServer.Columns as Columns import qualified Database.Relational.Schema.SQLServer.Indexes as Indexes import qualified Database.Relational.Schema.SQLServer.IndexColumns as IndexColumns import qualified Database.Relational.Schema.SQLServer.Types as Types import Control.Applicative ((<|>)) import Data.ByteString (ByteString) import Data.Char (toLower) import Data.Int (Int8, Int16, Int32, Int64) import Data.Map (Map) import Data.Time (LocalTime, Day, TimeOfDay) import Database.Relational (Query, Relation, PlaceHolders, Record, Flat, (!), (.=.), (><), asc, relationalQuery, just, placeholder', query, relation', unsafeShowSql, unsafeProjectSql, wheres) import Database.Relational.Schema.SQLServer.Config import Database.Relational.Schema.SQLServer.Columns import Database.Relational.Schema.SQLServer.Indexes import Database.Relational.Schema.SQLServer.IndexColumns import Database.Relational.Schema.SQLServer.Types import Language.Haskell.TH (TypeQ) --{-# ANN module "HLint: ignore Redundant $" #-} mapFromSqlDefault :: Map String TypeQ mapFromSqlDefault = Map.fromList [ ("text", [t|ByteString|]) , ("date", [t|Day|]) , ("time", [t|TimeOfDay|]) , ("tinyint", [t|Int8|]) , ("smallint", [t|Int16|]) , ("int", [t|Int32|]) , ("real", [t|Double|]) , ("datetime", [t|LocalTime|]) , ("float", [t|Double|]) , ("ntext", [t|String|]) , ("bit", [t|Char|]) , ("bigint", [t|Int64|]) , ("varchar", [t|String|]) , ("binary", [t|ByteString|]) , ("char", [t|String|]) , ("timestamp", [t|LocalTime|]) , ("nvarchar", [t|String|]) , ("nchar", [t|String|]) ] normalizeColumn :: String -> String normalizeColumn = map toLower notNull :: ((Columns,Types),String) -> Bool notNull ((cols,_),_) = isTrue . Columns.isNullable $ cols where isTrue (Just b) = not b isTrue _ = True getType :: Map String TypeQ -> ((Columns,Types),String) -> Maybe (String, TypeQ) getType mapFromSql rec@((cols,typs),typScms) = do colName <- Columns.name cols typ <- Map.lookup key mapFromSql <|> Map.lookup key mapFromSqlDefault return (normalizeColumn colName, mayNull typ) where key = if typScms == "sys" then Types.name typs else typScms ++ "." ++ Types.name typs mayNull typ = if notNull rec then typ else [t|Maybe $(typ)|] sqlsrvTrue :: Record Flat Bool sqlsrvTrue = unsafeProjectSql "1" sqlsrvObjectId :: Record Flat String -> Record Flat String -> Record Flat Int32 sqlsrvObjectId s t = unsafeProjectSql $ "OBJECT_ID(" ++ unsafeShowSql s ++ " + '.' + " ++ unsafeShowSql t ++ ")" sqlsrvOidPlaceHolder :: (PlaceHolders (String, String), Record Flat Int32) sqlsrvOidPlaceHolder = (nsParam >< relParam, oid) where (nsParam, (relParam, oid)) = placeholder' (\nsPh -> placeholder' (\relPh -> sqlsrvObjectId nsPh relPh)) columnTypeRelation :: Relation (String,String) ((Columns,Types),String) columnTypeRelation = relation' $ do cols <- query columns typs <- query types wheres $ cols ! Columns.userTypeId' .=. typs ! Types.userTypeId' wheres $ cols ! Columns.objectId' .=. oid asc $ cols ! Columns.columnId' return (params, cols >< typs >< sqlsrvSchemaName (typs ! Types.schemaId' :: Record Flat Int32)) where (params, oid) = sqlsrvOidPlaceHolder sqlsrvSchemaName i = unsafeProjectSql $ "SCHEMA_NAME(" ++ unsafeShowSql i ++ ")" columnTypeQuerySQL :: Query (String, String) ((Columns, Types), String) columnTypeQuerySQL = relationalQuery columnTypeRelation primaryKeyRelation :: Relation (String,String) (Maybe String) primaryKeyRelation = relation' $ do idxes <- query indexes idxcol <- query indexColumns cols <- query columns wheres $ idxes ! Indexes.objectId' .=. idxcol ! IndexColumns.objectId' wheres $ idxes ! Indexes.indexId' .=. idxcol ! IndexColumns.indexId' wheres $ idxcol ! IndexColumns.objectId' .=. cols ! Columns.objectId' wheres $ idxcol ! IndexColumns.columnId' .=. cols ! Columns.columnId' wheres $ idxes ! Indexes.isPrimaryKey' .=. just sqlsrvTrue let (params, oid) = sqlsrvOidPlaceHolder wheres $ idxes ! Indexes.objectId' .=. oid asc $ idxcol ! IndexColumns.keyOrdinal' return (params, cols ! Columns.name') primaryKeyQuerySQL :: Query (String,String) (Maybe String) primaryKeyQuerySQL = relationalQuery primaryKeyRelation relational-schemas-0.1.7.0/src/Database/Relational/Schema/Oracle.hs0000644000000000000000000001101613466565435023164 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} module Database.Relational.Schema.Oracle ( module Database.Relational.Schema.Oracle.Config , normalizeColumn, notNull, getType , columnsQuerySQL, primaryKeyQuerySQL ) where import Control.Applicative ((<|>)) import Data.ByteString (ByteString) import Data.Char (toLower) import Data.Map (Map) import qualified Data.Map as Map import Data.Time (LocalTime) import Language.Haskell.TH (TypeQ) import Database.Relational import Database.Relational.Schema.Oracle.Config import Database.Relational.Schema.Oracle.ConsColumns (dbaConsColumns) import qualified Database.Relational.Schema.Oracle.ConsColumns as ConsCols import Database.Relational.Schema.Oracle.Constraints (dbaConstraints) import qualified Database.Relational.Schema.Oracle.Constraints as Cons import Database.Relational.Schema.Oracle.TabColumns (DbaTabColumns, dbaTabColumns) import qualified Database.Relational.Schema.Oracle.TabColumns as Cols -- NOT COMPLETED -- (ref: http://docs.oracle.com/cd/B28359_01/server.111/b28318/datatype.htm) -- | Mapping between type in Oracle DB and Haskell type. mapFromSqlDefault :: Map String TypeQ mapFromSqlDefault = Map.fromList [ ("CHAR", [t|String|]) , ("VARCHAR", [t|String|]) -- deprecated , ("VARCHAR2", [t|String|]) , ("NCHAR", [t|String|]) , ("NVARCHAR2", [t|String|]) -- , ("NUMBER", [t|Integer or Double|]) see 'getType' , ("BINARY_FLOAT", [t|Double|]) -- Float don't work , ("BINARY_DOUBLE", [t|Double|]) , ("DATE", [t|LocalTime|]) , ("BLOB", [t|ByteString|]) , ("CLOB", [t|String|]) , ("NCLOB", [t|String|]) , ("LONG RAW", [t|ByteString|]) -- deprecated , ("RAW", [t|ByteString|]) , ("ROWID", [t|String|]) , ("UROWID", [t|String|]) ] -- | Normalize column name string to query Oracle DB data dictionary. normalizeColumn :: String -> String normalizeColumn = map toLower -- | Not-null attribute information of column. notNull :: DbaTabColumns -> Bool notNull = (== Just "N") . Cols.nullable -- | Get column normalized name and column Haskell type. getType :: Map String TypeQ -- ^ Type mapping specified by user -> DbaTabColumns -- ^ Column info in data dictionary -> Maybe (String, TypeQ) -- ^ Result normalized name and mapped Haskell type getType mapFromSql cols = do ky <- Cols.dataType cols typ <- if ky == "NUMBER" then return $ numberType $ Cols.dataScale cols else Map.lookup ky mapFromSql <|> Map.lookup ky mapFromSqlDefault return (normalizeColumn $ Cols.columnName cols, mayNull typ) where mayNull typ | notNull cols = typ | otherwise = [t|Maybe $(typ)|] numberType Nothing = [t|Integer|] numberType (Just n) | n <= 0 = [t|Integer|] | otherwise = [t|Double|] -- | 'Relation' to query 'DbaTabColumns' from owner name and table name. columnsRelationFromTable :: Relation (String, String) DbaTabColumns columnsRelationFromTable = relation' $ do cols <- query dbaTabColumns (owner, ()) <- placeholder $ \owner -> wheres $ cols ! Cols.owner' .=. owner (name, ()) <- placeholder $ \name -> wheres $ cols ! Cols.tableName' .=. name asc $ cols ! Cols.columnId' return (owner >< name, cols) -- | Phantom typed 'Query' to get 'DbaTabColumns' from owner name and table name. columnsQuerySQL :: Query (String, String) DbaTabColumns columnsQuerySQL = relationalQuery columnsRelationFromTable -- | 'Relation' to query primary key name from owner name and table name. primaryKeyRelation :: Relation (String, String) (Maybe String) primaryKeyRelation = relation' $ do cons <- query dbaConstraints cols <- query dbaTabColumns consCols <- query dbaConsColumns wheres $ cons ! Cons.owner' .=. just (cols ! Cols.owner') wheres $ cons ! Cons.tableName' .=. cols ! Cols.tableName' wheres $ consCols ! ConsCols.columnName' .=. just (cols ! Cols.columnName') wheres $ cons ! Cons.constraintName' .=. consCols ! ConsCols.constraintName' wheres $ cols ! Cols.nullable' .=. just (value "N") wheres $ cons ! Cons.constraintType' .=. just (value "P") (owner, ()) <- placeholder $ \owner -> wheres $ cons ! Cons.owner' .=. just owner (name, ()) <- placeholder $ \name -> wheres $ cons ! Cons.tableName' .=. name asc $ consCols ! ConsCols.position' return (owner >< name, consCols ! ConsCols.columnName') -- | Phantom typed 'Query' to get primary key name from owner name and table name. primaryKeyQuerySQL :: Query (String, String) (Maybe String) primaryKeyQuerySQL = relationalQuery primaryKeyRelation relational-schemas-0.1.7.0/src/Database/Relational/Schema/IBMDB2.hs0000644000000000000000000001056613466565435022667 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} -- | -- Module : Database.Relational.Schema.IBMDB2 -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module implements queries to get -- table schema and table constraint informations -- from system catalog of IBM DB2. module Database.Relational.Schema.IBMDB2 ( module Database.Relational.Schema.IBMDB2.Config, normalizeColumn, notNull, getType, columnsQuerySQL, primaryKeyQuerySQL ) where import Data.Int (Int16, Int32, Int64) import Data.Char (toLower) import Data.Map (Map, fromList) import qualified Data.Map as Map import Data.Time (LocalTime, Day) import Language.Haskell.TH (TypeQ) import Database.Relational (Query, relationalQuery, Relation, query, relation', wheres, (.=.), (!), (><), placeholder, asc, value) import Control.Applicative ((<|>)) import Database.Relational.Schema.IBMDB2.Config import Database.Relational.Schema.IBMDB2.Columns (Columns, columns) import qualified Database.Relational.Schema.IBMDB2.Columns as Columns import Database.Relational.Schema.IBMDB2.Tabconst (tabconst) import qualified Database.Relational.Schema.IBMDB2.Tabconst as Tabconst import Database.Relational.Schema.IBMDB2.Keycoluse (keycoluse) import qualified Database.Relational.Schema.IBMDB2.Keycoluse as Keycoluse -- | Mapping between type in DB2 and Haskell type. mapFromSqlDefault :: Map String TypeQ mapFromSqlDefault = fromList [("VARCHAR", [t|String|]), ("CHAR", [t|String|]), ("CHARACTER", [t|String|]), ("TIMESTAMP", [t|LocalTime|]), ("DATE", [t|Day|]), ("SMALLINT", [t|Int16|]), ("INTEGER", [t|Int32|]), ("BIGINT", [t|Int64|]), ("BLOB", [t|String|]), ("CLOB", [t|String|])] -- | Normalize column name string to query DB2 system catalog normalizeColumn :: String -> String normalizeColumn = map toLower -- | Not-null attribute information of column. notNull :: Columns -> Bool notNull = (== "N") . Columns.nulls -- | Get column normalized name and column Haskell type. getType :: Map String TypeQ -- ^ Type mapping specified by user -> Columns -- ^ Column info in system catalog -> Maybe (String, TypeQ) -- ^ Result normalized name and mapped Haskell type getType mapFromSql rec = do typ <- (Map.lookup key mapFromSql <|> Map.lookup key mapFromSqlDefault) return (normalizeColumn $ Columns.colname rec, mayNull typ) where key = Columns.typename rec mayNull typ = if notNull rec then typ else [t| Maybe $(typ) |] -- | 'Relation' to query 'Columns' from schema name and table name. columnsRelationFromTable :: Relation (String, String) Columns columnsRelationFromTable = relation' $ do c <- query columns (schemaP, ()) <- placeholder (\ph -> wheres $ c ! Columns.tabschema' .=. ph) (nameP , ()) <- placeholder (\ph -> wheres $ c ! Columns.tabname' .=. ph) asc $ c ! Columns.colno' return (schemaP >< nameP, c) -- | Phantom typed 'Query' to get 'Columns' from schema name and table name. columnsQuerySQL :: Query (String, String) Columns columnsQuerySQL = relationalQuery columnsRelationFromTable -- | 'Relation' to query primary key name from schema name and table name. primaryKeyRelation :: Relation (String, String) String primaryKeyRelation = relation' $ do cons <- query tabconst key <- query keycoluse col <- query columns wheres $ cons ! Tabconst.tabschema' .=. col ! Columns.tabschema' wheres $ cons ! Tabconst.tabname' .=. col ! Columns.tabname' wheres $ key ! Keycoluse.colname' .=. col ! Columns.colname' wheres $ cons ! Tabconst.constname' .=. key ! Keycoluse.constname' wheres $ col ! Columns.nulls' .=. value "N" wheres $ cons ! Tabconst.type' .=. value "P" wheres $ cons ! Tabconst.enforced' .=. value "Y" (schemaP, ()) <- placeholder (\ph -> wheres $ cons ! Tabconst.tabschema' .=. ph) (nameP , ()) <- placeholder (\ph -> wheres $ cons ! Tabconst.tabname' .=. ph) asc $ key ! Keycoluse.colseq' return (schemaP >< nameP, key ! Keycoluse.colname') -- | Phantom typed 'Query' to get primary key name from schema name and table name. primaryKeyQuerySQL :: Query (String, String) String primaryKeyQuerySQL = relationalQuery primaryKeyRelation relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL.hs0000644000000000000000000002003313466565435023761 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} -- | -- Module : Database.Relational.Schema.PostgreSQL -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module implements queries to get -- table schema and table constraint informations -- from system catalog of PostgreSQL. module Database.Relational.Schema.PostgreSQL ( module Database.Relational.Schema.PostgreSQL.Config, Column, normalizeColumn, notNull, getType, columnQuerySQL, primaryKeyLengthQuerySQL, primaryKeyQuerySQL ) where import Prelude hiding (or) import Language.Haskell.TH (TypeQ) import Data.Int (Int16, Int32, Int64) import Data.Char (toLower) import Data.List (foldl1') import Data.Map (Map, fromList) import qualified Data.Map as Map import Data.Time (DiffTime, NominalDiffTime, LocalTime, ZonedTime, Day, TimeOfDay) import Database.Relational (Query, relationalQuery, Relation, query, query', relation', relation, union, wheres, (.=.), (.>.), in', values, (!), fst', snd', placeholder, asc, value, unsafeProjectSql, (><)) import Database.Relational.Schema.PostgreSQL.Config import Database.Relational.Schema.PostgreSQL.PgNamespace (pgNamespace) import qualified Database.Relational.Schema.PostgreSQL.PgNamespace as Namespace import Database.Relational.Schema.PostgreSQL.PgClass (pgClass) import qualified Database.Relational.Schema.PostgreSQL.PgClass as Class import Database.Relational.Schema.PostgreSQL.PgConstraint (PgConstraint, pgConstraint) import qualified Database.Relational.Schema.PostgreSQL.PgConstraint as Constraint import Database.Relational.Schema.PostgreSQL.PgAttribute (PgAttribute, pgAttribute) import qualified Database.Relational.Schema.PostgreSQL.PgAttribute as Attr import Database.Relational.Schema.PostgreSQL.PgType (PgType(..), pgType) import qualified Database.Relational.Schema.PostgreSQL.PgType as Type import Control.Applicative ((<|>)) -- | Mapping between type in PostgreSQL and Haskell type. mapFromSqlDefault :: Map String TypeQ mapFromSqlDefault = fromList [("bool", [t| Bool |]), ("char", [t| Char |]), ("name", [t| String |]), ("int8", [t| Int64 |]), ("int2", [t| Int16 |]), ("int4", [t| Int32 |]), -- ("regproc", [t| Int32 |]), ("text", [t| String |]), ("oid", [t| Int32 |]), -- ("pg_node_tree", [t| String |]), ("float4", [t| Float |]), ("float8", [t| Double |]), ("abstime", [t| LocalTime |]), ("reltime", [t| NominalDiffTime |]), ("tinterval", [t| DiffTime |]), -- ("money", [t| Decimal |]), ("bpchar", [t| String |]), ("varchar", [t| String |]), ("date", [t| Day |]), ("time", [t| TimeOfDay |]), ("timestamp", [t| LocalTime |]), ("timestamptz", [t| ZonedTime |]), ("interval", [t| DiffTime |]), ("timetz", [t| ZonedTime |]) -- ("bit", [t| |]), -- ("varbit", [t| |]), -- ("numeric", [t| Decimal |]) ] -- | Normalize column name string to query PostgreSQL system catalog. normalizeColumn :: String -> String normalizeColumn = map toLower -- | Type to represent Column information. type Column = (PgAttribute, PgType) -- | Not-null attribute information of column. notNull :: Column -> Bool notNull = Attr.attnotnull . fst -- | Get column normalized name and column Haskell type. getType :: Map String TypeQ -- ^ Type mapping specified by user -> Column -- ^ Column info in system catalog -> Maybe (String, TypeQ) -- ^ Result normalized name and mapped Haskell type getType mapFromSql column@(pgAttr, pgTyp) = do typ <- (Map.lookup key mapFromSql <|> Map.lookup key mapFromSqlDefault) return (normalizeColumn $ Attr.attname pgAttr, mayNull typ) where key = Type.typname pgTyp mayNull typ = if notNull column then typ else [t| Maybe $typ |] -- | 'Relation' to query PostgreSQL relation oid from schema name and table name. relOidRelation :: Relation (String, String) Int32 relOidRelation = relation' $ do nsp <- query pgNamespace cls <- query pgClass wheres $ cls ! Class.relnamespace' .=. nsp ! Namespace.oid' (nspP, ()) <- placeholder (\ph -> wheres $ nsp ! Namespace.nspname' .=. ph) (relP, ()) <- placeholder (\ph -> wheres $ cls ! Class.relname' .=. ph) return (nspP >< relP, cls ! Class.oid') -- | 'Relation' to query column attribute from schema name and table name. attributeRelation :: Relation (String, String) PgAttribute attributeRelation = relation' $ do (ph, reloid) <- query' relOidRelation att <- query pgAttribute wheres $ att ! Attr.attrelid' .=. reloid wheres $ att ! Attr.attnum' .>. value 0 return (ph, att) -- | 'Relation' to query 'Column' from schema name and table name. columnRelation :: Relation (String, String) Column columnRelation = relation' $ do (ph, att) <- query' attributeRelation typ <- query pgType wheres $ att ! Attr.atttypid' .=. typ ! Type.oid' wheres $ typ ! Type.typtype' .=. value 'b' -- 'b': base type only wheres $ typ ! Type.typcategory' `in'` values [ 'B' -- Boolean types , 'D' -- Date/time types , 'I' -- Network Address types , 'N' -- Numeric types , 'S' -- String types , 'T' -- typespan types ] asc $ att ! Attr.attnum' return (ph, att >< typ) -- | Phantom typed 'Query' to get 'Column' from schema name and table name. columnQuerySQL :: Query (String, String) Column columnQuerySQL = relationalQuery columnRelation -- | 'Relation' to query primary key length from schema name and table name. primaryKeyLengthRelation :: Relation (String, String) Int32 primaryKeyLengthRelation = relation' $ do (ph, reloid) <- query' relOidRelation con <- query pgConstraint wheres $ con ! Constraint.conrelid' .=. reloid wheres $ con ! Constraint.contype' .=. value 'p' -- 'p': primary key constraint type return (ph, unsafeProjectSql "array_length (conkey, 1)") -- | Phantom typed 'Query' to get primary key length from schema name and table name. primaryKeyLengthQuerySQL :: Query (String, String) Int32 primaryKeyLengthQuerySQL = relationalQuery primaryKeyLengthRelation -- | One column which is nth column of composite primary key. constraintColRelation :: Int32 -> Relation () (PgConstraint, (Int16, Int32)) constraintColRelation i = relation $ do con <- query pgConstraint return $ con >< (unsafeProjectSql ("conkey[" ++ show i ++ "]") >< value i) -- | Make composite primary key relation from primary key length. constraintColExpandRelation :: Int32 -> Relation () (PgConstraint, (Int16, Int32)) constraintColExpandRelation n = foldl1' union [constraintColRelation i | i <- [1..n] ] -- | 'Relation' to query primary key name from schema name and table name. primaryKeyRelation :: Int32 -> Relation (String, String) String primaryKeyRelation n = relation' $ do (ph, att) <- query' attributeRelation conEx <- query (constraintColExpandRelation n) let con = conEx ! fst' col' = conEx ! snd' keyIx = col' ! fst' keyN = col' ! snd' wheres $ con ! Constraint.conrelid' .=. att ! Attr.attrelid' wheres $ keyIx .=. att ! Attr.attnum' wheres $ con ! Constraint.contype' .=. value 'p' -- 'p': primary key constraint type asc $ keyN return (ph, att ! Attr.attname') -- | Phantom typed 'Query' to get primary key name from schema name and table name. primaryKeyQuerySQL :: Int32 -> Query (String, String) String primaryKeyQuerySQL = relationalQuery . primaryKeyRelation relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3Syscat/0000755000000000000000000000000013466565435024037 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3Syscat/IndexInfo.hs0000644000000000000000000000042513466565435026257 0ustar0000000000000000module Database.Relational.Schema.SQLite3Syscat.IndexInfo {-# DEPRECATED "import Database.Relational.Schema.SQLite3.IndexInfo instead of this module." #-} ( module Database.Relational.Schema.SQLite3.IndexInfo, ) where import Database.Relational.Schema.SQLite3.IndexInfo relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3Syscat/Config.hs0000644000000000000000000000041613466565435025601 0ustar0000000000000000module Database.Relational.Schema.SQLite3Syscat.Config {-# DEPRECATED "import config from Database.Relational.Schema.SQLite3 instead of this module." #-} ( module Database.Relational.Schema.SQLite3.Config, ) where import Database.Relational.Schema.SQLite3.Config relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3Syscat/IndexList.hs0000644000000000000000000000042513466565435026277 0ustar0000000000000000module Database.Relational.Schema.SQLite3Syscat.IndexList {-# DEPRECATED "import Database.Relational.Schema.SQLite3.IndexList instead of this module." #-} ( module Database.Relational.Schema.SQLite3.IndexList, ) where import Database.Relational.Schema.SQLite3.IndexList relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3Syscat/TableInfo.hs0000644000000000000000000000042513466565435026237 0ustar0000000000000000module Database.Relational.Schema.SQLite3Syscat.TableInfo {-# DEPRECATED "import Database.Relational.Schema.SQLite3.TableInfo instead of this module." #-} ( module Database.Relational.Schema.SQLite3.TableInfo, ) where import Database.Relational.Schema.SQLite3.TableInfo relational-schemas-0.1.7.0/src/Database/Relational/Schema/Oracle/0000755000000000000000000000000013466565435022631 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/Oracle/TabColumns.hs0000644000000000000000000000762413466565435025245 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.Oracle.TabColumns where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.Oracle.Config (config) $(defineTableTypesAndRecord config "SYS" "dba_tab_columns" -- Column NULL? Datatype -- ----------------------------------------- -------- ---------------------------- -- OWNER NOT NULL VARCHAR2(30) [ ("owner", [t|String|]) -- TABLE_NAME NOT NULL VARCHAR2(30) , ("table_name", [t|String|]) -- COLUMN_NAME NOT NULL VARCHAR2(30) , ("column_name", [t|String|]) -- DATA_TYPE VARCHAR2(106) , ("data_type", [t|Maybe String|]) -- DATA_TYPE_MOD VARCHAR2(3) , ("data_type_mod", [t|Maybe String|]) -- DATA_TYPE_OWNER VARCHAR2(30) , ("data_type_owner", [t|Maybe String|]) -- DATA_LENGTH NOT NULL NUMBER , ("data_length", [t|Int32|]) -- DATA_PRECISION NUMBER , ("data_precision", [t|Maybe Int32|]) -- DATA_SCALE NUMBER , ("data_scale", [t|Maybe Int32|]) -- NULLABLE VARCHAR2(1) , ("nullable", [t|Maybe String|]) -- COLUMN_ID NUMBER , ("column_id", [t|Maybe Int32|]) -- DEFAULT_LENGTH NUMBER , ("default_length", [t|Maybe Int32|]) -- DATA_DEFAULT LONG , ("data_default", [t|Maybe String|]) -- NUM_DISTINCT NUMBER , ("num_distinct", [t|Maybe Int32|]) -- LOW_VALUE RAW(32) -- , ("low_value", [t|Maybe ByteString|]) -- HIGH_VALUE RAW(32) -- , ("high_value", [t|Maybe ByteString|]) -- DENSITY NUMBER , ("density", [t|Maybe Int32|]) -- NUM_NULLS NUMBER , ("num_nulls", [t|Maybe Int32|]) -- NUM_BUCKETS NUMBER , ("num_buckets", [t|Maybe Int32|]) -- LAST_ANALYZED DATE -- , ("last_analyzed", [t|Maybe Day|]) -- SAMPLE_SIZE NUMBER , ("sample_size", [t|Maybe Int32|]) -- CHARACTER_SET_NAME VARCHAR2(44) , ("character_set_name", [t|Maybe String|]) -- CHAR_COL_DECL_LENGTH NUMBER , ("char_col_decl_length", [t|Maybe Int32|]) -- GLOBAL_STATS VARCHAR2(3) , ("global_stats", [t|Maybe String|]) -- USER_STATS VARCHAR2(3) , ("user_stats", [t|Maybe String|]) -- AVG_COL_LEN NUMBER , ("avg_col_len", [t|Maybe Int32|]) -- CHAR_LENGTH NUMBER , ("char_length", [t|Maybe Int32|]) -- CHAR_USED VARCHAR2(1) , ("char_used", [t|Maybe String|]) -- V80_FMT_IMAGE VARCHAR2(3) , ("v80_fmt_image", [t|Maybe String|]) -- DATA_UPGRADED VARCHAR2(3) , ("data_upgraded", [t|Maybe String|]) -- HISTOGRAM VARCHAR2(15) , ("histogram", [t|Maybe String|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/Oracle/ConsColumns.hs0000644000000000000000000000222613466565435025432 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.Oracle.ConsColumns where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.Oracle.Config (config) $(defineTableTypesAndRecord config "SYS" "dba_cons_columns" -- Column NULL? Datatype -- ----------------------------------------- -------- ---------------------------- -- OWNER NOT NULL VARCHAR2(30) [ ("owner", [t|String|]) -- CONSTRAINT_NAME NOT NULL VARCHAR2(30) , ("constraint_name", [t|String|]) -- TABLE_NAME NOT NULL VARCHAR2(30) , ("table_name", [t|String|]) -- COLUMN_NAME VARCHAR2(4000) , ("column_name", [t|Maybe String|]) -- POSITION NUMBER , ("position", [t|Maybe Int32|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/Oracle/Config.hs0000644000000000000000000000064613466565435024400 0ustar0000000000000000-- | -- Module : Database.Relational.Schema.Oracle.Config -- Copyright : 2014-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.Oracle.Config (config) where import Database.Relational (Config, defaultConfig) -- | Configuration parameter against Oracle. config :: Config config = defaultConfig relational-schemas-0.1.7.0/src/Database/Relational/Schema/Oracle/Constraints.hs0000644000000000000000000000417013466565435025476 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.Oracle.Constraints where import GHC.Generics (Generic) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.Oracle.Config (config) $(defineTableTypesAndRecord config "SYS" "dba_constraints" -- Column NULL? Datatype -- ----------------------------------------- -------- ---------------------------- -- OWNER VARCHAR2(30) [ ("owner", [t|Maybe String|]) -- CONSTRAINT_NAME NOT NULL VARCHAR2(30) , ("constraint_name", [t|String|]) -- CONSTRAINT_TYPE VARCHAR2(1) , ("constraint_type", [t|Maybe String|]) -- TABLE_NAME NOT NULL VARCHAR2(30) , ("table_name", [t|String|]) -- SEARCH_CONDITION LONG -- R_OWNER VARCHAR2(30) -- R_CONSTRAINT_NAME VARCHAR2(30) -- DELETE_RULE VARCHAR2(9) -- STATUS VARCHAR2(8) -- DEFERRABLE VARCHAR2(14) -- DEFERRED VARCHAR2(9) -- VALIDATED VARCHAR2(13) -- GENERATED VARCHAR2(14) -- BAD VARCHAR2(3) -- RELY VARCHAR2(4) -- LAST_CHANGE DATE -- INDEX_OWNER VARCHAR2(30) -- INDEX_NAME VARCHAR2(30) -- INVALID VARCHAR2(7) -- VIEW_RELATED VARCHAR2(14) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQLInfo/0000755000000000000000000000000013466565435023205 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQLInfo/Config.hs0000644000000000000000000000034513466565435024750 0ustar0000000000000000module Database.Relational.Schema.MySQLInfo.Config {-# DEPRECATED "import config from Database.Relational.Schema.MySQL instead of this module." #-} ( config, ) where import Database.Relational.Schema.MySQL.Config (config) relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQLInfo/Columns.hs0000644000000000000000000000040313466565435025156 0ustar0000000000000000module Database.Relational.Schema.MySQLInfo.Columns {-# DEPRECATED "import Database.Relational.Schema.MySQL.Columns instead of this module." #-} ( module Database.Relational.Schema.MySQL.Columns, ) where import Database.Relational.Schema.MySQL.Columns relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/0000755000000000000000000000000013466565435023427 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/PgType.hs0000644000000000000000000000574713466565435025210 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.PostgreSQL.PgType -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.PostgreSQL.PgType where import GHC.Generics (Generic) import Data.Int (Int16, Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.PostgreSQL.Config (config) $(defineTableTypesAndRecord config "PG_CATALOG" "pg_type" [ ("oid", [t|Int32|]), -- Table "pg_catalog.pg_type" -- Column | Type | Modifiers -- ----------------+--------------+----------- -- typname | name | not null ("typname", [t|String|]), -- typnamespace | oid | not null ("typnamespace", [t|Int32|]), -- typowner | oid | not null ("typowner", [t|Int32|]), -- typlen | smallint | not null ("typlen", [t|Int16|]), -- typbyval | boolean | not null ("typbyval", [t|Bool|]), -- typtype | "char" | not null ("typtype", [t|Char|]), -- typcategory | "char" | not null ("typcategory", [t|Char|]), -- typispreferred | boolean | not null ("typispreferred", [t|Bool|]), -- typisdefined | boolean | not null ("typisdefined", [t|Bool|]), -- typdelim | "char" | not null ("typdelim", [t|Char|]), -- typrelid | oid | not null ("typrelid", [t|Int32|]), -- typelem | oid | not null ("typelem", [t|Int32|]), -- typarray | oid | not null ("typarray", [t|Int32|]), -- typinput | regproc | not null -- ("typinput", [t||]), -- typoutput | regproc | not null -- ("typoutput", [t||]), -- typreceive | regproc | not null -- ("typreceive", [t||]), -- typsend | regproc | not null -- ("typsend", [t||]), -- typmodin | regproc | not null -- ("typmodin", [t||]), -- typmodout | regproc | not null -- ("typmodout", [t||]), -- typanalyze | regproc | not null -- ("typanalyze", [t||]), -- typalign | "char" | not null ("typalign", [t|Char|]), -- typstorage | "char" | not null ("typstorage", [t|Char|]), -- typnotnull | boolean | not null ("typnotnull", [t|Bool|]), -- typbasetype | oid | not null ("typbasetype", [t|Int32|]), -- typtypmod | integer | not null ("typtypmod", [t|Int32|]), -- typndims | integer | not null ("typndims", [t|Int32|]), -- typcollation | oid | not null ("typcollation", [t|Int32|]), -- typdefaultbin | pg_node_tree | -- ("typdefaultbin", [t||]), -- typdefault | text | ("typdefault", [t|Maybe String|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/PgNamespace.hs0000644000000000000000000000156613466565435026156 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.PostgreSQL.PgNamespace -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.PostgreSQL.PgNamespace where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.PostgreSQL.Config (config) $(defineTableTypesAndRecord config "PG_CATALOG" "pg_namespace" [("oid" , [t| Int32 |]), -- nspname | name | not null ("nspname", [t| String |]) -- nspowner | oid | not null -- nspacl | aclitem[] | ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/PgClass.hs0000644000000000000000000000354613466565435025327 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.PostgreSQL.PgClass -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.PostgreSQL.PgClass where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.PostgreSQL.Config (config) $(defineTableTypesAndRecord config "PG_CATALOG" "pg_class" [("oid" , [t| Int32 |]), -- relname | name | not null ("relname" , [t| String |]), -- relnamespace | oid | not null ("relnamespace", [t| Int32 |]) -- reltype | oid | not null -- reloftype | oid | not null -- relowner | oid | not null -- relam | oid | not null -- relfilenode | oid | not null -- reltablespace | oid | not null -- relpages | integer | not null -- reltuples | real | not null -- reltoastrelid | oid | not null -- reltoastidxid | oid | not null -- relhasindex | boolean | not null -- relisshared | boolean | not null -- relpersistence | "char" | not null -- relkind | "char" | not null -- relnatts | smallint | not null -- relchecks | smallint | not null -- relhasoids | boolean | not null -- relhaspkey | boolean | not null -- relhasrules | boolean | not null -- relhastriggers | boolean | not null -- relhassubclass | boolean | not null -- relfrozenxid | xid | not null -- relacl | aclitem[] | -- reloptions | text[] | ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/Config.hs0000644000000000000000000000066213466565435025174 0ustar0000000000000000-- | -- Module : Database.Relational.Schema.PostgreSQL.Config -- Copyright : 2014-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.PostgreSQL.Config (config) where import Database.Relational (Config, defaultConfig) -- | Configuration parameter against PostgreSQL. config :: Config config = defaultConfig relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/PgConstraint.hs0000644000000000000000000000340113466565435026374 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.PostgreSQL.PgConstraint -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.PostgreSQL.PgConstraint where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.PostgreSQL.Config (config) $(defineTableTypesAndRecord config "PG_CATALOG" "pg_constraint" [ -- ("oid" , [t| Int32 |]), -- conname | name | not null -- connamespace | oid | not null -- contype | "char" | not null ("contype", [t| Char |]), -- condeferrable | boolean | not null -- condeferred | boolean | not null -- convalidated | boolean | not null -- conrelid | oid | not null ("conrelid", [t| Int32 |]) -- contypid | oid | not null -- conindid | oid | not null -- confrelid | oid | not null -- confupdtype | "char" | not null -- confdeltype | "char" | not null -- confmatchtype | "char" | not null -- conislocal | boolean | not null -- coninhcount | integer | not null -- conkey | smallint[] | -- ("conkey", ???), -- confkey | smallint[] | -- conpfeqop | oid[] | -- conppeqop | oid[] | -- conffeqop | oid[] | -- conexclop | oid[] | -- conbin | pg_node_tree | -- consrc | text | ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/PostgreSQL/PgAttribute.hs0000644000000000000000000000444413466565435026223 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.HDBC.Schema.PostgreSQL.PgAttribute -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.PostgreSQL.PgAttribute where import GHC.Generics (Generic) import Data.Int (Int16, Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.PostgreSQL.Config (config) $(defineTableTypesAndRecord config "PG_CATALOG" "pg_attribute" [ -- Table "pg_catalog.pg_attribute" -- Column | Type | Modifiers -- ---------------+-----------+----------- -- attrelid | oid | not null ("attrelid" , [t|Int32|]), -- attname | name | not null ("attname" , [t|String|]), -- atttypid | oid | not null ("atttypid" , [t|Int32|]), -- attstattarget | integer | not null ("attstattarget", [t|Int32|]), -- attlen | smallint | not null ("attlen" , [t|Int16|]), -- attnum | smallint | not null ("attnum" , [t|Int16|]), -- attndims | integer | not null ("attndims" , [t|Int32|]), -- attcacheoff | integer | not null ("attcacheoff" , [t|Int32|]), -- atttypmod | integer | not null ("atttypmod" , [t|Int32|]), -- attbyval | boolean | not null ("attbyval" , [t|Bool|]), -- attstorage | "char" | not null ("attstorage" , [t|Char|]), -- attalign | "char" | not null ("attalign" , [t|Char|]), -- attnotnull | boolean | not null ("attnotnull" , [t|Bool|]), -- atthasdef | boolean | not null ("atthasdef" , [t|Bool|]), -- attisdropped | boolean | not null ("attisdropped", [t|Bool|]), -- attislocal | boolean | not null ("attislocal" , [t|Bool|]), -- attinhcount | integer | not null ("attinhcount" , [t|Int32|]), -- attcollation | oid | not null ("attcollation", [t|Int32|]) -- attacl | aclitem[] | -- ("attacl" , [t|String|]), -- attoptions | text[] | -- ("attoptions" , [t|String|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/DB2Syscat/0000755000000000000000000000000013466565435023162 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/DB2Syscat/Config.hs0000644000000000000000000000034713466565435024727 0ustar0000000000000000module Database.Relational.Schema.DB2Syscat.Config {-# DEPRECATED "import config from Database.Relational.Schema.IBMDB2 instead of this module." #-} ( config, ) where import Database.Relational.Schema.IBMDB2.Config (config) relational-schemas-0.1.7.0/src/Database/Relational/Schema/DB2Syscat/Columns.hs0000644000000000000000000000040613466565435025136 0ustar0000000000000000module Database.Relational.Schema.DB2Syscat.Columns {-# DEPRECATED "import Database.Relational.Schema.IBMDB2.Columns instead of this module." #-} ( module Database.Relational.Schema.IBMDB2.Columns, ) where import Database.Relational.Schema.IBMDB2.Columns relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer/0000755000000000000000000000000013466565435023252 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer/Indexes.hs0000644000000000000000000000474613466565435025220 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLServer.Indexes where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLServer.Config (config) $(defineTableTypesAndRecord config "sys" "indexes" [ -- View "sys.indexes" -- column schema type length NULL -- --------------------- ------- ------------------- -------- ------ -- object_id sys int 4 No ("object_id", [t|Int32|]), -- name sys sysname(nvarchar) 128 Yes --("name", [t|Maybe String|]), -- index_id sys int 4 No ("index_id", [t|Int32|]), -- type sys tinyint 1 No --("type", [t|Char|]), -- type_desc sys nvarchar 60 Yes --("type_desc", [t|Maybe String|]), -- is_unique sys bit 1 Yes --("is_unique", [t|Maybe Bool|]), -- data_space_id sys int 4 No --("data_space_id", [t|Int32|]), -- ignore_dup_key sys bit 1 Yes --("ignore_dup_key", [t|Maybe Bool|]), -- is_primary_key sys bit 1 Yes ("is_primary_key", [t|Maybe Bool|])--, -- is_unique_constraint sys bit 1 Yes --("is_unique_constraint", [t|Maybe Bool|]), -- fill_factor sys tinyint 1 No --("fill_factor", [t|Int32|]), -- is_padded sys bit 1 Yes --("is_padded", [t|Maybe Bool|]), -- is_disabled sys bit 1 Yes --("is_disabled", [t|Maybe Bool|]), -- is_hypothetical sys bit 1 Yes --("is_hypothetical", [t|Maybe Bool|]), -- allow_row_locks sys bit 1 Yes --("allow_row_locks", [t|Maybe Bool|]), -- allow_page_locks sys bit 1 Yes --("allow_page_locks", [t|Maybe Bool|]), -- has_filter sys bit 1 Yes --("has_filter", [t|Maybe Bool|]), -- filter_definition sys nvarchar max Yes --("filter_definition", [t|Maybe ByteString|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer/Types.hs0000644000000000000000000000416013466565435024713 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLServer.Types where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLServer.Config (config) $(defineTableTypesAndRecord config "sys" "types" [ -- View "sys.types" -- column schema type length NULL -- --------------------- ------- ------------------- -------- ------ -- name sys sysname(nvarchar) 128 No ("name", [t|String|]), -- system_type_id sys tinyint 1 No --("system_type_id", [t|Int32|]), -- user_type_id sys int 4 No ("user_type_id", [t|Int32|]), -- schema_id sys int 4 No ("schema_id", [t|Int32|])--, -- principal_id sys int 4 Yes --("principal_id", [t|Maybe Int32|]), -- max_length sys int 4 No --("max_length", [t|Int32|]), -- precision sys tinyint 1 No --("precision", [t|Int32|]), -- scale sys tinyint 1 No --("scale", [t|Int32|]), -- collation_name sys sysname(nvarchar) 128 Yes --("collation_name", [t|Maybe String|]), -- is_nullable sys bit 1 Yes --("is_nullable", [t|Maybe Bool|]), -- is_user_defined sys bit 1 No --("is_user_defined", [t|Bool|]), -- is_assembly_type sys bit 1 No --("is_assembly_type", [t|Bool|]), -- default_object_id sys int 4 No --("default_object_id", [t|Int32|]), -- rule_object_id sys int 4 No --("rule_object_id", [t|Int32|]), -- is_table_type sys bit 1 No --("is_table_type", [t|Bool|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer/Config.hs0000644000000000000000000000065713466565435025023 0ustar0000000000000000-- | -- Module : Database.Relational.Schema.PgCatalog.Config -- Copyright : 2014-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.SQLServer.Config (config) where import Database.Relational (Config, defaultConfig) -- | Configuration parameter against SQLServer. config :: Config config = defaultConfig relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer/Columns.hs0000644000000000000000000000626713466565435025241 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLServer.Columns where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLServer.Config (config) $(defineTableTypesAndRecord config "sys" "columns" [ -- column schema type length NULL -- --------------------- ------- ------------------- -------- ------ -- object_id sys int 4 No ("object_id", [t|Int32|]), -- name sys sysname(nvarchar) 128 Yes ("name", [t|Maybe String|]), -- column_id sys int 4 No ("column_id", [t|Int32|]), -- system_type_id sys tinyint 1 No --("system_type_id", [t|Int32|]), -- user_type_id sys int 4 No ("user_type_id", [t|Int32|]), -- max_length sys smallint 2 No --("max_length", [t|Int32|]), -- precision sys tinyint 1 No --("precision", [t|Int32|]), -- scale sys tinyint 1 No --("scale", [t|Int32|]), -- collation_name sys sysname(nvarchar) 128 Yes --("collation_name", [t|Maybe String|]), -- is_nullable sys bit 1 Yes ("is_nullable", [t|Maybe Bool|])--, -- is_ansi_padded sys bit 1 No --("is_ansi_padded", [t|Bool|]), -- is_rowguidcol sys bit 1 No --("is_rowguidcol", [t|Bool|]), -- is_identity sys bit 1 No --("is_identity", [t|Bool|]), -- is_computed sys bit 1 No --("is_computed", [t|Bool|]), -- is_filestream sys bit 1 No --("is_filestream", [t|Bool|]), -- is_replicated sys bit 1 Yes --("is_replicated", [t|Maybe Bool|]), -- is_non_sql_subscribed sys bit 1 Yes --("is_non_sql_subscribed", [t|Maybe Bool|]), -- is_merge_published sys bit 1 Yes --("is_merge_published", [t|Maybe Bool|]), -- is_dts_repllicated sys bit 1 Yes --("is_dts_replicated", [t|Maybe Bool|]), -- is_xml_document sys bit 1 No --("is_xml_document", [t|Bool|]), -- xml_collection_id sys int 4 No --("xml_collection_id", [t|Int32|]), -- default_object_id sys int 4 No --("default_object_id", [t|Int32|]), -- rule_object_id sys int 4 No --("rule_object_id", [t|Int32|]), -- is_sparse sys bit 1 Yes --("is_sparse", [t|Maybe Bool|]), -- is_column_set sys bit 1 Yes --("is_column_set", [t|Maybe Bool|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServer/IndexColumns.hs0000644000000000000000000000250413466565435026217 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLServer.IndexColumns where import GHC.Generics (Generic) import Data.Int (Int32) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLServer.Config (config) $(defineTableTypesAndRecord config "sys" "index_columns" [ -- column schema type length NULL -- --------------------- ------- ------------------- -------- ------ -- object_id sys int 4 No ("object_id", [t|Int32|]), -- index_id sys int 4 No ("index_id", [t|Int32|]), -- index_column_id sys int 4 No ("column_id", [t|Int32|]), -- key_ordinal sys tinyint 1 No ("key_ordinal", [t|Int32|]), -- partition_ordinal sys tinyint 1 No --("partition_ordinal", [t|Int32|]), -- is_descending_key sys bit 1 No --("is_descending_key", [t|Bool|]), -- is_included_column sys bit 1 No ("is_included_column", [t|Bool|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQL/0000755000000000000000000000000013466565435022371 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQL/TableConstraints.hs0000644000000000000000000000123413466565435026204 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.MySQL.TableConstraints where import GHC.Generics (Generic) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.MySQL.Config (config) $(defineTableTypesAndRecord config "INFORMATION_SCHEMA" "table_constraints" [ ("table_schema" , [t| String |]) , ("table_name" , [t| String |]) , ("constraint_name" , [t| String |]) , ("constraint_type" , [t| String |]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQL/KeyColumnUsage.hs0000644000000000000000000000136113466565435025621 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.MySQL.KeyColumnUsage where import GHC.Generics (Generic) import Data.Int (Int16) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.MySQL.Config (config) $(defineTableTypesAndRecord config "INFORMATION_SCHEMA" "key_column_usage" [ ("constraint_name" , [t| String |]) , ("table_schema" , [t| String |]) , ("table_name" , [t| String |]) , ("column_name" , [t| String |]) , ("ordinal_position" , [t| Int16 |]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQL/Config.hs0000644000000000000000000000071013466565435024130 0ustar0000000000000000-- | -- Module : Database.Relational.Schema.MySQL.Config -- Copyright : 2014-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.MySQL.Config (config) where import Database.Relational (Config (..), defaultConfig) -- | Configuration parameter against MySQL. config :: Config config = defaultConfig { normalizedTableName = False } relational-schemas-0.1.7.0/src/Database/Relational/Schema/MySQL/Columns.hs0000644000000000000000000000144513466565435024351 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.MySQL.Columns where import GHC.Generics (Generic) import Data.Int (Int16) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.MySQL.Config (config) $(defineTableTypesAndRecord config "INFORMATION_SCHEMA" "columns" [ ("table_schema", [t|String|]) , ("table_name", [t|String|]) , ("column_name", [t|String|]) , ("ordinal_position", [t|Int16|]) , ("column_default", [t|Maybe String|]) , ("is_nullable", [t|String|]) , ("data_type", [t|String|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/PgCatalog/0000755000000000000000000000000013466565435023265 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/PgCatalog/PgType.hs0000644000000000000000000000041613466565435025032 0ustar0000000000000000module Database.Relational.Schema.PgCatalog.PgType {-# DEPRECATED "import Database.Relational.Schema.PostgreSQL.PgType instead of this module." #-} ( module Database.Relational.Schema.PostgreSQL.PgType, ) where import Database.Relational.Schema.PostgreSQL.PgType relational-schemas-0.1.7.0/src/Database/Relational/Schema/PgCatalog/Config.hs0000644000000000000000000000035713466565435025033 0ustar0000000000000000module Database.Relational.Schema.PgCatalog.Config {-# DEPRECATED "import config from Database.Relational.Schema.PostgreSQL instead of this module." #-} ( config, ) where import Database.Relational.Schema.PostgreSQL.Config (config) relational-schemas-0.1.7.0/src/Database/Relational/Schema/PgCatalog/PgAttribute.hs0000644000000000000000000000044213466565435026053 0ustar0000000000000000module Database.Relational.Schema.PgCatalog.PgAttribute {-# DEPRECATED "import Database.Relational.Schema.PostgreSQL.PgAttribute instead of this module." #-} ( module Database.Relational.Schema.PostgreSQL.PgAttribute, ) where import Database.Relational.Schema.PostgreSQL.PgAttribute relational-schemas-0.1.7.0/src/Database/Relational/Schema/OracleDataDictionary/0000755000000000000000000000000013466565435025451 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/OracleDataDictionary/TabColumns.hs0000644000000000000000000000043513466565435030056 0ustar0000000000000000module Database.Relational.Schema.OracleDataDictionary.TabColumns {-# DEPRECATED "import Database.Relational.Schema.Oracle.TabColumns instead of this module." #-} ( module Database.Relational.Schema.Oracle.TabColumns, ) where import Database.Relational.Schema.Oracle.TabColumns relational-schemas-0.1.7.0/src/Database/Relational/Schema/OracleDataDictionary/Config.hs0000644000000000000000000000036213466565435027213 0ustar0000000000000000module Database.Relational.Schema.OracleDataDictionary.Config {-# DEPRECATED "import config from Database.Relational.Schema.Oracle instead of this module." #-} ( config, ) where import Database.Relational.Schema.Oracle.Config (config) relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServerSyscat/0000755000000000000000000000000013466565435024441 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServerSyscat/Types.hs0000644000000000000000000000041513466565435026101 0ustar0000000000000000module Database.Relational.Schema.SQLServerSyscat.Types {-# DEPRECATED "import Database.Relational.Schema.SQLServer.Types instead of this module." #-} ( module Database.Relational.Schema.SQLServer.Types, ) where import Database.Relational.Schema.SQLServer.Types relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServerSyscat/Config.hs0000644000000000000000000000042613466565435026204 0ustar0000000000000000module Database.Relational.Schema.SQLServerSyscat.Config {-# DEPRECATED "import config from Database.Relational.Schema.SQLServer instead of this module." #-} ( module Database.Relational.Schema.SQLServer.Config, ) where import Database.Relational.Schema.SQLServer.Config relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLServerSyscat/Columns.hs0000644000000000000000000000042513466565435026416 0ustar0000000000000000module Database.Relational.Schema.SQLServerSyscat.Columns {-# DEPRECATED "import Database.Relational.Schema.SQLServer.Columns instead of this module." #-} ( module Database.Relational.Schema.SQLServer.Columns, ) where import Database.Relational.Schema.SQLServer.Columns relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3/0000755000000000000000000000000013466565435022650 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3/IndexInfo.hs0000644000000000000000000000150313466565435025066 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLite3.IndexInfo where import GHC.Generics (Generic) import Data.Int (Int64) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLite3.Config (config) $(defineTableTypesAndRecord config "pragma" "index_info" [ -- pragma "index_info" -- column type NULL -- --------------------- ------------------- ------ -- seqno integer No ("seqno", [t|Int64|]), -- cid integer No ("cid", [t|Int64|]), -- name text No ("name", [t|String|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3/Config.hs0000644000000000000000000000073513466565435024416 0ustar0000000000000000-- | -- Module : Database.Relational.Schema.SQLite3.Config -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.SQLite3.Config (config) where import Database.Relational (Config (addModifyTableAliasAS), defaultConfig) -- | Configuration parameter against SQLite3. config :: Config config = defaultConfig { addModifyTableAliasAS = True } relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3/IndexList.hs0000644000000000000000000000151113466565435025105 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLite3.IndexList where import GHC.Generics (Generic) import Data.Int (Int64) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLite3.Config (config) $(defineTableTypesAndRecord config "pragma" "index_list" [ -- pragma "main.index_list" -- column type NULL -- --------------------- ------------------- ------ -- seq integer No ("seq", [t|Int64|]), -- name text No ("name", [t|String|]), -- unique integer No ("unique", [t|Int64|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/SQLite3/TableInfo.hs0000644000000000000000000000207613466565435025054 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} module Database.Relational.Schema.SQLite3.TableInfo where import GHC.Generics (Generic) import Data.Int (Int16, Int64) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.SQLite3.Config (config) $(defineTableTypesAndRecord config "pragma" "table_info" [ -- View "main.sqlite_master" -- column type NULL -- --------------------- ------------------- ------ -- cid integer No ("cid", [t|Int64|]), -- name text No ("name", [t|String|]), -- type text No ("ctype", [t|String|]), -- notnull integer No ("notnull", [t|Int16|]), -- dflt_value - Yes ("dflt_value", [t|Maybe String|]), -- pk integer No ("pk", [t|Int16|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/IBMDB2/0000755000000000000000000000000013466565435022323 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Relational/Schema/IBMDB2/Config.hs0000644000000000000000000000075513466565435024073 0ustar0000000000000000-- | -- Module : Database.Relational.Schema.IBMDB2.Config -- Copyright : 2014-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown module Database.Relational.Schema.IBMDB2.Config (config) where import Database.Relational (Config (..), ProductUnitSupport (..), defaultConfig) -- | Configuration parameter against IBM DB2. config :: Config config = defaultConfig { productUnitSupport = PUNotSupported } relational-schemas-0.1.7.0/src/Database/Relational/Schema/IBMDB2/Keycoluse.hs0000644000000000000000000000201313466565435024616 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.DB2Syscat.Keycoluse -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- Generate template of SYSCAT.keycoluse system catalog table. -- Not all columns are mapped to Haskell record. -- Minimum implementation required to generate table constraints. module Database.Relational.Schema.IBMDB2.Keycoluse where import GHC.Generics (Generic) import Data.Int (Int16) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.IBMDB2.Config (config) -- Not all column is mapped. Minimum implementation. $(defineTableTypesAndRecord config "SYSCAT" "keycoluse" [("constname", [t| String |]), ("colname" , [t| String |]), ("colseq" , [t| Int16 |])] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/IBMDB2/Columns.hs0000644000000000000000000001221613466565435024301 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.IBMDB2.Columns -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- Generate template of SYSCAT.columns system catalog table. module Database.Relational.Schema.IBMDB2.Columns where import GHC.Generics (Generic) import Data.Int (Int16, Int32, Int64) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.IBMDB2.Config (config) $(defineTableTypesAndRecord config "SYSCAT" "columns" [ -- column schema type length NULL -- ------------------------------ --------- ------------------ -------- ----- ------ -- TABSCHEMA SYSIBM VARCHAR 128 0 No ("tabschema", [t|String|]), -- TABNAME SYSIBM VARCHAR 128 0 No ("tabname", [t|String|]), -- COLNAME SYSIBM VARCHAR 128 0 No ("colname", [t|String|]), -- COLNO SYSIBM SMALLINT 2 0 No ("colno", [t|Int16|]), -- TYPESCHEMA SYSIBM VARCHAR 128 0 No ("typeschema", [t|String|]), -- TYPENAME SYSIBM VARCHAR 18 0 No ("typename", [t|String|]), -- LENGTH SYSIBM INTEGER 4 0 No ("length", [t|Int32|]), -- SCALE SYSIBM SMALLINT 2 0 No ("scale", [t|Int16|]), -- DEFAULT SYSIBM VARCHAR 254 0 Yes ("default", [t|Maybe String|]), -- NULLS SYSIBM CHARACTER 1 0 No ("nulls", [t|String|]), -- CODEPAGE SYSIBM SMALLINT 2 0 No ("codepage", [t|Int16|]), -- LOGGED SYSIBM CHARACTER 1 0 No ("logged", [t|String|]), -- COMPACT SYSIBM CHARACTER 1 0 No ("compact", [t|String|]), -- COLCARD SYSIBM BIGINT 8 0 No ("colcard", [t|Int64|]), -- HIGH2KEY SYSIBM VARCHAR 254 0 Yes ("high2key", [t|Maybe String|]), -- LOW2KEY SYSIBM VARCHAR 254 0 Yes ("low2key", [t|Maybe String|]), -- AVGCOLLEN SYSIBM INTEGER 4 0 No ("avgcollen", [t|Int32|]), -- KEYSEQ SYSIBM SMALLINT 2 0 Yes ("keyseq", [t|Maybe Int16|]), -- PARTKEYSEQ SYSIBM SMALLINT 2 0 Yes ("partkeyseq", [t|Maybe Int16|]), -- NQUANTILES SYSIBM SMALLINT 2 0 No ("nquantiles", [t|Int16|]), -- NMOSTFREQ SYSIBM SMALLINT 2 0 No ("nmostfreq", [t|Int16|]), -- NUMNULLS SYSIBM BIGINT 8 0 No ("numnulls", [t|Int64|]), -- TARGET_TYPESCHEMA SYSIBM VARCHAR 128 0 Yes ("target_typeschema", [t|Maybe String|]), -- TARGET_TYPENAME SYSIBM VARCHAR 18 0 Yes ("target_typename", [t|Maybe String|]), -- SCOPE_TABSCHEMA SYSIBM VARCHAR 128 0 Yes ("scope_tabschema", [t|Maybe String|]), -- SCOPE_TABNAME SYSIBM VARCHAR 128 0 Yes ("scope_tabname", [t|Maybe String|]), -- SOURCE_TABSCHEMA SYSIBM VARCHAR 128 0 Yes ("source_tabschema", [t|Maybe String|]), -- SOURCE_TABNAME SYSIBM VARCHAR 128 0 Yes ("source_tabname", [t|Maybe String|]), -- DL_FEATURES SYSIBM CHARACTER 10 0 Yes ("dl_features", [t|Maybe String|]), -- SPECIAL_PROPS SYSIBM CHARACTER 8 0 Yes ("special_props", [t|Maybe String|]), -- HIDDEN SYSIBM CHARACTER 1 0 No ("hidden", [t|String|]), -- INLINE_LENGTH SYSIBM INTEGER 4 0 No ("inline_length", [t|Int32|]), -- IDENTITY SYSIBM CHARACTER 1 0 No ("identity", [t|String|]), -- GENERATED SYSIBM CHARACTER 1 0 No ("generated", [t|String|]), -- TEXT SYSIBM CLOB 65538 0 Yes ("text", [t|Maybe String|]), -- REMARKS SYSIBM VARCHAR 254 0 Yes ("remarks", [t|Maybe String|]) ] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Relational/Schema/IBMDB2/Tabconst.hs0000644000000000000000000000207013466565435024433 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE DeriveGeneric #-} -- | -- Module : Database.Relational.Schema.DB2Syscat.Tabconst -- Copyright : 2013-2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- Generate template of SYSCAT.tabconst system catalog table. -- Not all columns are mapped to Haskell record. -- Minimum implementation required to generate table constraints. module Database.Relational.Schema.IBMDB2.Tabconst where import GHC.Generics (Generic) import Database.Relational.TH (defineTableTypesAndRecord) import Database.Relational.Schema.IBMDB2.Config (config) -- Not all column is mapped. Minimum implementation. $(defineTableTypesAndRecord config "SYSCAT" "tabconst" [("constname", [t| String |]), ("tabschema", [t| String |]), ("tabname" , [t| String |]), -- ("type" , [t| String |]), ("enforced" , [t| String |])] [''Show, ''Generic]) relational-schemas-0.1.7.0/src/Database/Custom/0000755000000000000000000000000013466565435017404 5ustar0000000000000000relational-schemas-0.1.7.0/src/Database/Custom/MySQL.hs0000644000000000000000000000450213466565435020706 0ustar0000000000000000-- | -- Module : Database.Custom.MySQL -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module provides custom APIs with appropriate configuration -- for MySQL. module Database.Custom.MySQL ( module Database.Relational, relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) where import Database.Relational.Schema.MySQL.Config (config) import Database.Relational hiding (relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) -- | From 'Relation' into typed 'Query' with suffix SQL words. relationalQuery :: Relation p r -> QuerySuffix -> Query p r relationalQuery = relationalQuery_ config -- | Make 'Insert' from derived table and monadic builded 'Register' object. insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p insertValue = insertValue' config -- | Make 'Insert' from derived table and monadic builded 'Register' object with no(unit) placeholder. insertValueNoPH :: TableDerivable r => Register r () -> Insert () insertValueNoPH body = insertValue $ body >> return unitPH -- | Make 'InsertQuery' from derived table, 'Pi' and 'Relation'. insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p insertQuery = insertQuery' config -- | Make 'Update' from derived table and 'Assign' computation. update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p update = update' config -- | Make 'Update' from derived table and 'Assign' computation with no(unit) placeholder. updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () updateNoPH body = update $ (>> return unitPH) . body -- | Make 'Delete' from derived table and 'Restrict' computation. delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p delete = delete' config -- | Make 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder. deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () deleteNoPH body = delete $ (>> return unitPH) . body relational-schemas-0.1.7.0/src/Database/Custom/SQLite3.hs0000644000000000000000000000451213466565435021166 0ustar0000000000000000-- | -- Module : Database.Custom.SQLite3 -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module provides custom APIs with appropriate configuration -- for SQLite3. module Database.Custom.SQLite3 ( module Database.Relational, relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) where import Database.Relational.Schema.SQLite3.Config (config) import Database.Relational hiding (relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) -- | From 'Relation' into typed 'Query' with suffix SQL words. relationalQuery :: Relation p r -> QuerySuffix -> Query p r relationalQuery = relationalQuery_ config -- | Make 'Insert' from derived table and monadic builded 'Register' object. insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p insertValue = insertValue' config -- | Make 'Insert' from derived table and monadic builded 'Register' object with no(unit) placeholder. insertValueNoPH :: TableDerivable r => Register r () -> Insert () insertValueNoPH body = insertValue $ body >> return unitPH -- | Make 'InsertQuery' from derived table, 'Pi' and 'Relation'. insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p insertQuery = insertQuery' config -- | Make 'Update' from derived table and 'Assign' computation. update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p update = update' config -- | Make 'Update' from derived table and 'Assign' computation with no(unit) placeholder. updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () updateNoPH body = update $ (>> return unitPH) . body -- | Make 'Delete' from derived table and 'Restrict' computation. delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p delete = delete' config -- | Make 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder. deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () deleteNoPH body = delete $ (>> return unitPH) . body relational-schemas-0.1.7.0/src/Database/Custom/SQLServer.hs0000644000000000000000000000452213466565435021571 0ustar0000000000000000-- | -- Module : Database.Custom.SQLServer -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module provides custom APIs with appropriate configuration -- for SQLServer. module Database.Custom.SQLServer ( module Database.Relational, relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) where import Database.Relational.Schema.SQLServer.Config (config) import Database.Relational hiding (relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) -- | From 'Relation' into typed 'Query' with suffix SQL words. relationalQuery :: Relation p r -> QuerySuffix -> Query p r relationalQuery = relationalQuery_ config -- | Make 'Insert' from derived table and monadic builded 'Register' object. insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p insertValue = insertValue' config -- | Make 'Insert' from derived table and monadic builded 'Register' object with no(unit) placeholder. insertValueNoPH :: TableDerivable r => Register r () -> Insert () insertValueNoPH body = insertValue $ body >> return unitPH -- | Make 'InsertQuery' from derived table, 'Pi' and 'Relation'. insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p insertQuery = insertQuery' config -- | Make 'Update' from derived table and 'Assign' computation. update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p update = update' config -- | Make 'Update' from derived table and 'Assign' computation with no(unit) placeholder. updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () updateNoPH body = update $ (>> return unitPH) . body -- | Make 'Delete' from derived table and 'Restrict' computation. delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p delete = delete' config -- | Make 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder. deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () deleteNoPH body = delete $ (>> return unitPH) . body relational-schemas-0.1.7.0/src/Database/Custom/Oracle.hs0000644000000000000000000000450613466565435021152 0ustar0000000000000000-- | -- Module : Database.Custom.Oracle -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module provides custom APIs with appropriate configuration -- for Oracle. module Database.Custom.Oracle ( module Database.Relational, relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) where import Database.Relational.Schema.Oracle.Config (config) import Database.Relational hiding (relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) -- | From 'Relation' into typed 'Query' with suffix SQL words. relationalQuery :: Relation p r -> QuerySuffix -> Query p r relationalQuery = relationalQuery_ config -- | Make 'Insert' from derived table and monadic builded 'Register' object. insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p insertValue = insertValue' config -- | Make 'Insert' from derived table and monadic builded 'Register' object with no(unit) placeholder. insertValueNoPH :: TableDerivable r => Register r () -> Insert () insertValueNoPH body = insertValue $ body >> return unitPH -- | Make 'InsertQuery' from derived table, 'Pi' and 'Relation'. insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p insertQuery = insertQuery' config -- | Make 'Update' from derived table and 'Assign' computation. update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p update = update' config -- | Make 'Update' from derived table and 'Assign' computation with no(unit) placeholder. updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () updateNoPH body = update $ (>> return unitPH) . body -- | Make 'Delete' from derived table and 'Restrict' computation. delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p delete = delete' config -- | Make 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder. deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () deleteNoPH body = delete $ (>> return unitPH) . body relational-schemas-0.1.7.0/src/Database/Custom/IBMDB2.hs0000644000000000000000000000450613466565435020644 0ustar0000000000000000-- | -- Module : Database.Custom.IBMDB2 -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module provides custom APIs with appropriate configuration -- for IBMDB2. module Database.Custom.IBMDB2 ( module Database.Relational, relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) where import Database.Relational.Schema.IBMDB2.Config (config) import Database.Relational hiding (relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) -- | From 'Relation' into typed 'Query' with suffix SQL words. relationalQuery :: Relation p r -> QuerySuffix -> Query p r relationalQuery = relationalQuery_ config -- | Make 'Insert' from derived table and monadic builded 'Register' object. insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p insertValue = insertValue' config -- | Make 'Insert' from derived table and monadic builded 'Register' object with no(unit) placeholder. insertValueNoPH :: TableDerivable r => Register r () -> Insert () insertValueNoPH body = insertValue $ body >> return unitPH -- | Make 'InsertQuery' from derived table, 'Pi' and 'Relation'. insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p insertQuery = insertQuery' config -- | Make 'Update' from derived table and 'Assign' computation. update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p update = update' config -- | Make 'Update' from derived table and 'Assign' computation with no(unit) placeholder. updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () updateNoPH body = update $ (>> return unitPH) . body -- | Make 'Delete' from derived table and 'Restrict' computation. delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p delete = delete' config -- | Make 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder. deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () deleteNoPH body = delete $ (>> return unitPH) . body relational-schemas-0.1.7.0/src/Database/Custom/PostgreSQL.hs0000644000000000000000000000452613466565435021752 0ustar0000000000000000-- | -- Module : Database.Custom.PostgreSQL -- Copyright : 2019 Kei Hibino -- License : BSD3 -- -- Maintainer : ex8k.hibino@gmail.com -- Stability : experimental -- Portability : unknown -- -- This module provides custom APIs with appropriate configuration -- for PostgreSQL. module Database.Custom.PostgreSQL ( module Database.Relational, relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) where import Database.Relational.Schema.PostgreSQL.Config (config) import Database.Relational hiding (relationalQuery, insertValue, insertValueNoPH, insertQuery, update, updateNoPH, delete, deleteNoPH, ) -- | From 'Relation' into typed 'Query' with suffix SQL words. relationalQuery :: Relation p r -> QuerySuffix -> Query p r relationalQuery = relationalQuery_ config -- | Make 'Insert' from derived table and monadic builded 'Register' object. insertValue :: TableDerivable r => Register r (PlaceHolders p) -> Insert p insertValue = insertValue' config -- | Make 'Insert' from derived table and monadic builded 'Register' object with no(unit) placeholder. insertValueNoPH :: TableDerivable r => Register r () -> Insert () insertValueNoPH body = insertValue $ body >> return unitPH -- | Make 'InsertQuery' from derived table, 'Pi' and 'Relation'. insertQuery :: TableDerivable r => Pi r r' -> Relation p r' -> InsertQuery p insertQuery = insertQuery' config -- | Make 'Update' from derived table and 'Assign' computation. update :: TableDerivable r => (Record Flat r -> Assign r (PlaceHolders p)) -> Update p update = update' config -- | Make 'Update' from derived table and 'Assign' computation with no(unit) placeholder. updateNoPH :: TableDerivable r => (Record Flat r -> Assign r ()) -> Update () updateNoPH body = update $ (>> return unitPH) . body -- | Make 'Delete' from derived table and 'Restrict' computation. delete :: TableDerivable r => (Record Flat r -> Restrict (PlaceHolders p)) -> Delete p delete = delete' config -- | Make 'Delete' from 'defaultConfig', derived table and 'Restrict' computation with no(unit) placeholder. deleteNoPH :: TableDerivable r => (Record Flat r -> Restrict ()) -> Delete () deleteNoPH body = delete $ (>> return unitPH) . body