Module

Yoga.SQL.Types

Package: purescript-yoga-sql-types
Repository: rowtype-yoga/purescript-yoga-sql-types

#SQLQuery Source

data SQLQuery :: Row Type -> Typedata SQLQuery rows

A SQL query that tracks its parameters at the type level The row type r represents { paramName :: paramType, ... }

Constructors

SQLQuery (Array String) String

#sqlQueryToString Source

sqlQueryToString :: forall r. SQLQuery r -> String

#SQLParameter Source

data SQLParameter

Opaque SQL parameter type (database-specific)

Instances

(ToSQLParam n) => Folding TurnIntoSQLParam (Array SQLParameter) n (Array SQLParameter)
(ToSQLParam n, IsSymbol sym) => FoldingWithIndex TurnIntoSQLParam (Proxy sym) (Map String SQLParameter) n (Map String SQLParameter)

#SQLResult Source

data SQLResult

Opaque SQL result type (database-specific)

#ToSQLParam Source

class ToSQLParam a  where

Members

toSQLParam :: a -> SQLParameter

Instances

ToSQLParam Int
ToSQLParam String
ToSQLParam Number
ToSQLParam Boolean
(ToSQLParam a) => ToSQLParam (Array a)
(ToSQLParam a) => ToSQLParam (NonEmptyArray a)
(ToSQLParam a) => ToSQLParam (Maybe a)
(ToSQLParam b, Newtype a b) => ToSQLParam a
(Coercible a b, ToSQLParam b) => ToSQLParam b

#fromSQLValue Source

fromSQLValue :: forall @a. SQLFromForeign a => SQLResult -> Either String a

#SQLFromForeign Source

class SQLFromForeign a  where

Members

fromSQLResultImpl :: Foreign -> ExceptT (NonEmptyList ForeignError) Identity a

Instances

SQLFromForeign Boolean
SQLFromForeign Int
SQLFromForeign String
SQLFromForeign Number
(SQLFromForeign a) => SQLFromForeign (Array a)
(SQLFromForeign a) => SQLFromForeign (Maybe a)

#singleResult Source

singleResult :: forall @a b. SQLFromForeign a => (a -> b) -> Array SQLResult -> Either String b

#twoResults Source

twoResults :: forall @a @b c. SQLFromForeign a => SQLFromForeign b => (a -> b -> c) -> Array SQLResult -> Either String c

#threeResults Source

threeResults :: forall @a @b @c d. SQLFromForeign a => SQLFromForeign b => SQLFromForeign c => (a -> b -> c -> d) -> Array SQLResult -> Either String d

#fourResults Source

fourResults :: forall @a @b @c @d e. SQLFromForeign a => SQLFromForeign b => SQLFromForeign c => SQLFromForeign d => (a -> b -> c -> d -> e) -> Array SQLResult -> Either String e

#fiveResults Source

fiveResults :: forall @a @b @c @d @e f. SQLFromForeign a => SQLFromForeign b => SQLFromForeign c => SQLFromForeign d => SQLFromForeign e => (a -> b -> c -> d -> e -> f) -> Array SQLResult -> Either String f

#FromResultArray Source

class FromResultArray fn a | fn -> a where

Members

fromResultArray :: fn -> Array SQLResult -> Either String a

Instances

(SQLFromForeign a, SQLFromForeign b, SQLFromForeign c, SQLFromForeign d, SQLFromForeign e) => FromResultArray (a -> b -> c -> d -> e -> f) f
(SQLFromForeign a, SQLFromForeign b, SQLFromForeign c, SQLFromForeign d) => FromResultArray (a -> b -> c -> d -> e) e
(SQLFromForeign a, SQLFromForeign b, SQLFromForeign c) => FromResultArray (a -> b -> c -> d) d
(SQLFromForeign a, SQLFromForeign b) => FromResultArray (a -> b -> c) c
(SQLFromForeign a) => FromResultArray (a -> b) b

#TurnIntoSQLParam Source

data TurnIntoSQLParam

Constructors

TurnIntoSQLParam

Instances

(ToSQLParam n) => Folding TurnIntoSQLParam (Array SQLParameter) n (Array SQLParameter)
(ToSQLParam n, IsSymbol sym) => FoldingWithIndex TurnIntoSQLParam (Proxy sym) (Map String SQLParameter) n (Map String SQLParameter)

#SQLBuilder Source

newtype SQLBuilder :: Row Type -> Row Type -> Typenewtype SQLBuilder r1 r2

Constructors

SQLBuilder (SQLQuery r1 -> SQLQuery r2)

Instances

ToBuilder (SQLBuilder r1 r2) r1 r2

#ToBuilder Source

class ToBuilder :: Type -> Row Type -> Row Type -> Constraintclass ToBuilder s r1 r2 | r1 -> r2, r2 -> r1 where

Members

toBuilder :: s -> SQLBuilder r1 r2

Instances

ToBuilder (SQLBuilder r1 r2) r1 r2
ToBuilder String r r

#combineBuilders Source

combineBuilders :: forall a b r1 r2 r3. ToBuilder a r2 r3 => ToBuilder b r1 r2 => a -> b -> SQLBuilder r1 r3

Compose two builders

#(^) Source

Operator alias for Yoga.SQL.Types.combineBuilders (left-associative / precedence 8)

#sql Source

sql :: forall r. SQLBuilder () r -> SQLQuery r

Create a SQL query from a builder

#arg Source

arg :: forall @a @sym r1 r2. IsSymbol sym => ToSQLParam a => Cons sym a r1 r2 => SQLBuilder r1 r2

Add a typed parameter to the query

#int Source

int :: forall @sym r1 r2. IsSymbol sym => Cons sym Int r1 r2 => SQLBuilder r1 r2

Add an Int parameter

#str Source

str :: forall @sym r1 r2. IsSymbol sym => Cons sym String r1 r2 => SQLBuilder r1 r2

Add a String parameter

#bool Source

bool :: forall @sym r1 r2. IsSymbol sym => Cons sym Boolean r1 r2 => SQLBuilder r1 r2

Add a Boolean parameter

#num Source

num :: forall @sym r1 r2. IsSymbol sym => Cons sym Number r1 r2 => SQLBuilder r1 r2

Add a Number parameter

#nonArg Source

nonArg :: forall r. String -> SQLBuilder r r

Add a literal SQL string (no parameter)

#argsFor Source

argsFor :: forall @params. HFoldlWithIndex TurnIntoSQLParam (Map String SQLParameter) (Record params) (Map String SQLParameter) => SQLQuery params -> Record params -> Array SQLParameter

Extract parameters from a record in the correct order

#DatabaseColumns Source

newtype DatabaseColumns row

Constructors

DatabaseColumns row

#SQLiteBaseType Source

data SQLiteBaseType

Constructors

#renderBaseType Source

renderBaseType :: SQLiteBaseType -> String

#Constraint Source

data Constraint

Constructors

#renderConstraint Source

renderConstraint :: Constraint -> String

#SQLColumn Source

data SQLColumn

Constructors

SQLColumn SQLiteBaseType (Array Constraint)

#TableName Source

newtype TableName

Constructors

TableName String

Instances

Newtype TableName _

#ColumnName Source

newtype ColumnName

Constructors

ColumnName String

Instances

Newtype ColumnName _

#Table Source

data Table :: Row Type -> Typedata Table columns

A table with typed columns

Constructors

Table TableName (Record columns)

#MapRecord Source

data MapRecord a b

Constructors

MapRecord (String -> a -> b)

Instances

(IsSymbol sym, Lacks sym rb, Cons sym b rb rc) => FoldingWithIndex (MapRecord a b) (Proxy sym) (Builder (Record ra) (Record rb)) a (Builder (Record ra) (Record rc))

#mapRecordWithIndex Source

mapRecordWithIndex :: forall @a @b @rin @rout. HFoldlWithIndex (MapRecord a b) (Builder (Record ()) (Record ())) (Record rin) (Builder (Record ()) (Record rout)) => (String -> a -> b) -> Record rin -> Record rout

#table Source

table :: forall @cols. Homogeneous cols SQLColumn => TableName -> Record cols -> Table cols

Create a table schema

#columnNamesOf Source

columnNamesOf :: forall cols colsRL out. RowToList cols colsRL => HFoldlWithIndex (MapRecord SQLColumn ColumnName) (Builder (Record ()) (Record ())) (Record cols) (Builder (Record ()) (Record out)) => Table cols -> Record out

Extract column names from table schema

#CreateTableStatement Source

newtype CreateTableStatement

Constructors

CreateTableStatement String

Instances

Newtype CreateTableStatement _

#createTable Source

createTable :: forall cols. Homogeneous cols SQLColumn => Table cols -> CreateTableStatement

Generate CREATE TABLE statement from schema

Modules: Yoga.SQL.PostgresTypes; Yoga.SQL.Types