úÎL`I2.      !"#$%&'()*+,-DAsks a ODBC database to infer selected types and placeholder types. Data source name SQL  (parameterinput -info, returncolumn/output -info)       Like 1 but also considers if the SqlValue is nullable. .Like 1 but also considers if the SqlValue is nullable. /Given a 0, it returns a function f which transforms a D SqlValue into another type. The return type of f is dependent upon  the value of 0'. The function f is encapsulated in an  1 . Also see . The opposite of  in that it returns a function  from a type to 2*. Similarly the function is returned in a  1. See .    ?Parses an extended SQL string. The extionsion is that we allow A variable-ids after placeholders (question marks). We return the E list of identifiers and the SQL string without the variable-ids. If B no variable-id is found after a placeholder, the empty string is  returned as variable-id. 34$"Parts used in prepared statements "Describing a positional parameter <Common parts for both statements run directly (runStmt) and  prepared statements. Positional parameters 4Description of values returned from a SQL statement 6The SQL expression which is passed on to the database  Name of the  Connection parameter. !;Makes the query result from prepareStmt or runStmt strict. 5)Returns all parameters which is unbound. "BContructs expression-parts. A database is contacting to parse the  SQL and infer correct types. #7Statically typed one-off (not prepared) SQL statement. Data source name (DSN) ;SQL statement extended with question marks for parameteres The expression has type  1Connection -> a1 -> ... -> an -> IO [x1, ... xm]),  where a1-an1 are inputs to the statement (due to placeholder  arguments), and x1-xm% are the outputs from the statement. ;If there are no outputs from the statement (e.g. an insert 5 statement) the number of affected rows is returned. $AConstructs a lambda which given a connection and parameters will  execute expr. See %. 4Expression which is expected to access the database %?Creates an exprresion which runs a SQL statement on a database E server. It is expected that the connection variable and parameters " has already been bound. See also $. &*Statically typed prepared SQL statement. Data source name (DSN) ;SQL statement extended with question marks for parameteres The expression has type  5Connection -> IO (a1 -> ... -> an -> IO [x1, ... xm]),  where a1-an1 are inputs to the statement (due to placeholder  arguments), and x1-xm& are the outputs from the statement. ;If there are no outputs from the statement (e.g. an insert 5 statement) the number of affected rows is returned. '.Creates parts for a prepared statement. Calls ". (!Lambda for prepared statements. )2A StmtQ which prepares a statement on a database. *.A StmtQ to execute a statement on a database. +@Creates a StmtQ of type: IO (a1-an -> IO ... ). Where a1-an are % the parameters which must be bound. 6CConverts parameters to SqlValue. The conversions is based upon the 5 SqlTypeId-s retried from the database and stored in parts. ,8Returns textual information about a query. The returned 7 B is useful as presentation to a user, not for further processing. 8AExecutes a prepared statement and returns all rows. The rows are  retrieved lazily. -9BParses sql and gets a database server to infer types for selected  types and placeholder types. ::Outputs returned from running a SQL statement needs to be ; converted into Haskell types. This TH function returns an & expression which do this conversion. ;Data source name (DSN) ;SQL statement extended with question marks for parameteres The expression has type  1Connection -> a1 -> ... -> an -> IO [x1, ... xm]),  where a1-an1 are inputs to the statement (due to placeholder  arguments), and x1-xm% are the outputs from the statement. ;If there are no outputs from the statement (e.g. an insert ' statement) the unit type is returned. <=?Parameters given to a SQL statement needs to be converted from D there Haskell type to something HDBC understand - namely SqlValue. B This TH function returns an expression to do the conversion. The ; returned function is split into its pattern and its body. 6(variable name, type). Variable names may be equal to "".  !"#$%&'()*+,-#&! -,"$%'()*+  !"#$%&'()*+,-'  !"#$%&'()*+,- >      !"#$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMetaHDBC-0.1.2Database.MetaHDBC Database.MetaHDBC.OdbcInferTypesDatabase.MetaHDBC.ConnectionDatabase.MetaHDBC.SqlTypeIdExpQ!Database.MetaHDBC.SimpleSqlParserDatabase.MetaHDBC.SqlExpr HDBC-2.2.7.0Database.HDBC.Typesrollbackcommit disconnectHDBC-odbc-2.2.3.2Database.HDBC.ODBC.Connection connectODBC!Database.HDBC.ODBC.ConnectionImpl Connection dbInferTypes strictListCachingConnectionhdbcConnection statementMapcachingConnectioncachingPreparefromSqlColDesc toSqlColDesc fromSqlTypeId toSqlTypeIdsimpleSqlParser PrepareParts exprPartsstmtName ParameterparmNametypeIDisBound ExprParts parameters returnTypes dbSqlExprconnectionNamestrict makeExprPartsrunStmt runStmtLHS runStmtRHS prepareStmtmakePrepStmtParts prepStmtLHS prepStmtQexecPrepStmtRHSreturnExecPrepStmtLHSsqlInfo rethrowDoingmaybeFromTypeId maybeToTypeIdDatabase.HDBC.ColTypes SqlTypeIdtemplate-haskellLanguage.Haskell.TH.LibExpQDatabase.HDBC.SqlValueSqlValueparseVar splitWhenunboundParameters convertParamsbaseGHC.BaseString fetchRows inferTypesfromRow cachingStmt prepareParts' fromParams'