relational-schemas-0.1.8.0/0000755000000000000000000000000013633421207013620 5ustar0000000000000000relational-schemas-0.1.8.0/ChangeLog.md0000644000000000000000000000207613633421207015776 0ustar0000000000000000 ## 0.1.8.0 - update for GHC 8.8.x. - allow more type-categories of PostgreSQL. ## 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.8.0/relational-schemas.cabal0000644000000000000000000001377213633421207020371 0ustar0000000000000000name: relational-schemas version: 0.1.8.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.8.1, GHC == 8.8.2 , 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 , sql-words , 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 if impl(ghc >= 8) && impl(ghc < 8.8) ghc-options: -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.8.0/Setup.hs0000644000000000000000000000005613633421207015255 0ustar0000000000000000import Distribution.Simple main = defaultMain relational-schemas-0.1.8.0/LICENSE0000644000000000000000000000275613633421207014637 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.8.0/src/0000755000000000000000000000000013633421207014407 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/0000755000000000000000000000000013633421207016113 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Custom/0000755000000000000000000000000013633421207017365 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Custom/PostgreSQL.hs0000644000000000000000000000506613633421207021733 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 Language.SQL.Keyword (Keyword) 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 -- ^ relation to finalize building -> [Keyword] -- ^ suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ... -> Query p r -- ^ finalized query 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.8.0/src/Database/Custom/SQLite3.hs0000644000000000000000000000505213633421207021147 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 Language.SQL.Keyword (Keyword) 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 -- ^ relation to finalize building -> [Keyword] -- ^ suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ... -> Query p r -- ^ finalized query 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.8.0/src/Database/Custom/MySQL.hs0000644000000000000000000000504213633421207020667 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 Language.SQL.Keyword (Keyword) 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 -- ^ relation to finalize building -> [Keyword] -- ^ suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ... -> Query p r -- ^ finalized query 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.8.0/src/Database/Custom/SQLServer.hs0000644000000000000000000000506213633421207021552 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 Language.SQL.Keyword (Keyword) 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 -- ^ relation to finalize building -> [Keyword] -- ^ suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ... -> Query p r -- ^ finalized query 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.8.0/src/Database/Custom/Oracle.hs0000644000000000000000000000504613633421207021133 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 Language.SQL.Keyword (Keyword) 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 -- ^ relation to finalize building -> [Keyword] -- ^ suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ... -> Query p r -- ^ finalized query 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.8.0/src/Database/Custom/IBMDB2.hs0000644000000000000000000000504613633421207020625 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 Language.SQL.Keyword (Keyword) 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 -- ^ relation to finalize building -> [Keyword] -- ^ suffix SQL words. for example, `[FOR, UPDATE]`, `[FETCH, FIRST, "3", ROWS, ONLY]` ... -> Query p r -- ^ finalized query 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.8.0/src/Database/Relational/0000755000000000000000000000000013633421207020205 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/0000755000000000000000000000000013633421207021405 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/PostgreSQL.hs0000644000000000000000000001750013633421207023747 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, (.=.), (.>.), not', 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 |]), ("uuid", [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 $ not' $ typ ! Type.typcategory' `in'` values [ 'C' -- Composite types , 'P' -- Pseudo-types , 'X' -- unknown type ] 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.8.0/src/Database/Relational/Schema/SQLite3.hs0000644000000000000000000000647413633421207023200 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.8.0/src/Database/Relational/Schema/MySQL.hs0000644000000000000000000001114113633421207022704 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.8.0/src/Database/Relational/Schema/SQLServer.hs0000644000000000000000000001223413633421207023571 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.8.0/src/Database/Relational/Schema/Oracle.hs0000644000000000000000000001101613633421207023145 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.8.0/src/Database/Relational/Schema/IBMDB2.hs0000644000000000000000000001056613633421207022650 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.8.0/src/Database/Relational/Schema/SQLServerSyscat/0000755000000000000000000000000013633421207024422 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/SQLServerSyscat/Config.hs0000644000000000000000000000042613633421207026165 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.8.0/src/Database/Relational/Schema/SQLServerSyscat/Columns.hs0000644000000000000000000000042513633421207026377 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.8.0/src/Database/Relational/Schema/SQLServerSyscat/Types.hs0000644000000000000000000000041513633421207026062 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.8.0/src/Database/Relational/Schema/DB2Syscat/0000755000000000000000000000000013633421207023143 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/DB2Syscat/Config.hs0000644000000000000000000000034713633421207024710 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.8.0/src/Database/Relational/Schema/DB2Syscat/Columns.hs0000644000000000000000000000040613633421207025117 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.8.0/src/Database/Relational/Schema/SQLite3/0000755000000000000000000000000013633421207022631 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/SQLite3/Config.hs0000644000000000000000000000073513633421207024377 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.8.0/src/Database/Relational/Schema/SQLite3/IndexList.hs0000644000000000000000000000151113633421207025066 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.8.0/src/Database/Relational/Schema/SQLite3/TableInfo.hs0000644000000000000000000000207613633421207025035 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.8.0/src/Database/Relational/Schema/SQLite3/IndexInfo.hs0000644000000000000000000000150313633421207025047 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.8.0/src/Database/Relational/Schema/MySQLInfo/0000755000000000000000000000000013633421207023166 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/MySQLInfo/Config.hs0000644000000000000000000000034513633421207024731 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.8.0/src/Database/Relational/Schema/MySQLInfo/Columns.hs0000644000000000000000000000040313633421207025137 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.8.0/src/Database/Relational/Schema/OracleDataDictionary/0000755000000000000000000000000013633421207025432 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/OracleDataDictionary/Config.hs0000644000000000000000000000036213633421207027174 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.8.0/src/Database/Relational/Schema/OracleDataDictionary/TabColumns.hs0000644000000000000000000000043513633421207030037 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.8.0/src/Database/Relational/Schema/IBMDB2/0000755000000000000000000000000013633421207022304 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/IBMDB2/Config.hs0000644000000000000000000000075513633421207024054 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.8.0/src/Database/Relational/Schema/IBMDB2/Columns.hs0000644000000000000000000001221613633421207024262 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.8.0/src/Database/Relational/Schema/IBMDB2/Keycoluse.hs0000644000000000000000000000201313633421207024577 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.8.0/src/Database/Relational/Schema/IBMDB2/Tabconst.hs0000644000000000000000000000207013633421207024414 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.8.0/src/Database/Relational/Schema/PgCatalog/0000755000000000000000000000000013633421207023246 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/PgCatalog/PgAttribute.hs0000644000000000000000000000044213633421207026034 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.8.0/src/Database/Relational/Schema/PgCatalog/Config.hs0000644000000000000000000000035713633421207025014 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.8.0/src/Database/Relational/Schema/PgCatalog/PgType.hs0000644000000000000000000000041613633421207025013 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.8.0/src/Database/Relational/Schema/MySQL/0000755000000000000000000000000013633421207022352 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/MySQL/Config.hs0000644000000000000000000000071013633421207024111 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.8.0/src/Database/Relational/Schema/MySQL/Columns.hs0000644000000000000000000000144513633421207024332 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.8.0/src/Database/Relational/Schema/MySQL/KeyColumnUsage.hs0000644000000000000000000000136113633421207025602 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.8.0/src/Database/Relational/Schema/MySQL/TableConstraints.hs0000644000000000000000000000123413633421207026165 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.8.0/src/Database/Relational/Schema/Oracle/0000755000000000000000000000000013633421207022612 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/Oracle/Config.hs0000644000000000000000000000064613633421207024361 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.8.0/src/Database/Relational/Schema/Oracle/ConsColumns.hs0000644000000000000000000000222613633421207025413 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.8.0/src/Database/Relational/Schema/Oracle/Constraints.hs0000644000000000000000000000417013633421207025457 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.8.0/src/Database/Relational/Schema/Oracle/TabColumns.hs0000644000000000000000000000762413633421207025226 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.8.0/src/Database/Relational/Schema/SQLite3Syscat/0000755000000000000000000000000013633421207024020 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/SQLite3Syscat/Config.hs0000644000000000000000000000041613633421207025562 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.8.0/src/Database/Relational/Schema/SQLite3Syscat/IndexList.hs0000644000000000000000000000042513633421207026260 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.8.0/src/Database/Relational/Schema/SQLite3Syscat/TableInfo.hs0000644000000000000000000000042513633421207026220 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.8.0/src/Database/Relational/Schema/SQLite3Syscat/IndexInfo.hs0000644000000000000000000000042513633421207026240 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.8.0/src/Database/Relational/Schema/PostgreSQL/0000755000000000000000000000000013633421207023410 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/PostgreSQL/PgAttribute.hs0000644000000000000000000000444413633421207026204 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.8.0/src/Database/Relational/Schema/PostgreSQL/Config.hs0000644000000000000000000000066213633421207025155 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.8.0/src/Database/Relational/Schema/PostgreSQL/PgNamespace.hs0000644000000000000000000000156613633421207026137 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.8.0/src/Database/Relational/Schema/PostgreSQL/PgConstraint.hs0000644000000000000000000000340113633421207026355 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.8.0/src/Database/Relational/Schema/PostgreSQL/PgType.hs0000644000000000000000000000574713633421207025171 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.8.0/src/Database/Relational/Schema/PostgreSQL/PgClass.hs0000644000000000000000000000354613633421207025310 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.8.0/src/Database/Relational/Schema/SQLServer/0000755000000000000000000000000013633421207023233 5ustar0000000000000000relational-schemas-0.1.8.0/src/Database/Relational/Schema/SQLServer/Config.hs0000644000000000000000000000065713633421207025004 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.8.0/src/Database/Relational/Schema/SQLServer/Columns.hs0000644000000000000000000000626713633421207025222 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.8.0/src/Database/Relational/Schema/SQLServer/Indexes.hs0000644000000000000000000000474613633421207025201 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.8.0/src/Database/Relational/Schema/SQLServer/IndexColumns.hs0000644000000000000000000000250413633421207026200 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.8.0/src/Database/Relational/Schema/SQLServer/Types.hs0000644000000000000000000000416013633421207024674 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])