root/trunk/sdbo/odbc_stmt.d

/********************************************************
 *                                                      *
 * Copyright (c) 2004 Wolfgang Borgsmüller (wb@sapo.pt) *
 *                                                      *
 * Usage of the works is permitted provided that this   *
 * instrument is retained with the works, so that any   *
 * entity that uses the works is notified of this       *
 * instrument.                                          *
 *                                                      *
 * DISCLAIMER: THE WORKS ARE WITHOUT WARRANTY.          *
 *                                                      *
 * [2004, Fair License: rhid.com/fair]                  *
 ********************************************************/

/*! \if never
*/
 
module sdbo.odbc_stmt;

private import std.stdio;
private import std.string;



version(linux) {
    version = bundled_headers;
}

version(bundled_headers) {
    private import sdbo._odbc_headers.sql;
    private import sdbo._odbc_headers.sqlext;
    private import sdbo._odbc_headers.sqltypes;
    version(Windows)
        private import sdbo._odbc_headers.odbc32dll;
    
} else {
    private import std.c.windows.sql;
    private import std.c.windows.sqlext;
    private import std.c.windows.sqltypes;
    private import std.c.windows.odbc32dll;
}

private import sdbo.odbc_env;
private import sdbo.odbc_dbc;
private import sdbo.odbc_etc;

/*! \endif
*/



/*! \brief Helper class for the statement handle hstmt. 
 *
 * 
 *
 */
 
public class SqlResult
{
    
    private struct Binding
    {
        bit allocated;
        bit bound;

        SQLPOINTER buffer;
        SQLINTEGER bufLen;
        SQLINTEGER* StrLen_or_IndPtr; /* this integer goes into the dll so it must be malloc'd */
    }
    
    private struct ParamBinding
    {
        
        SQLINTEGER  valueType;
        SQLINTEGER  paramType;
        
        Binding binding;
    }
    
    private struct ColumnBinding
    {
        SQLINTEGER targetType = UNBOUND;

        Binding binding;
    }
    
    public enum : int {
        D_LONG =   SQL_C_SBIGINT,
        D_INT =    SQL_C_SLONG,
        D_SHORT =  SQL_C_SSHORT,
        D_DOUBLE = SQL_C_DOUBLE,
        D_FLOAT =  SQL_C_FLOAT,
        D_CHAR =   SQL_C_CHAR, 
        D_WCHAR =  SQL_C_WCHAR,
        
        UNBOUND = 0
    }

    private static SQLINTEGER defaultTarget(int sqlType) {
        
        //writefln("defaultTarget(sql type %d)", sqlType);
        
        switch(sqlType) {
            
            case SQL_BIGINT:            return SQL_C_SBIGINT; /* odbc assigns char as default for this */
            case SQL_TYPE_DATE:         return SQL_C_CHAR;
            case SQL_TYPE_TIME:         return SQL_C_CHAR;
            case SQL_TYPE_TIMESTAMP:    return SQL_C_CHAR;
            default:                    return SQL_C_DEFAULT;
        }
    }
    

    private static bit checkTarget(int dType, int sqlType, int targetType)
    {
        if(dType == targetType) 
            return true;
        
        if(targetType == SQL_C_DEFAULT) {
            
            /* for columns bound with SQL_C_DEFAULT, check for sql types with compatible c type */
            
            switch(dType) {
                
                case D_INT:     return sqlType == SQL_INTEGER;
                case D_SHORT:   return sqlType == SQL_SMALLINT;
                case D_DOUBLE:  return sqlType == SQL_DOUBLE || sqlType == SQL_FLOAT;
                case D_FLOAT:   return sqlType == SQL_REAL;
                case D_CHAR:    return sqlType == SQL_CHAR || sqlType == SQL_VARCHAR || sqlType == SQL_LONGVARCHAR || sqlType == SQL_NUMERIC || sqlType == SQL_BIGINT;
                
                case D_LONG:    
                case D_WCHAR:   
                default:        return false;
            }
            
        }
        return false;
    }
    
        
    package OdbcConnection dbc;
    private SqlResult next = null;
    private SqlResult previous = null;
    
    package HSTMT hstmt;
    
    
    
    private ColumnSpec*[] cspecs;
    private ColumnBinding*[] cbindings;
    private ParamBinding*[] pbindings;
    
    private uint[char[]] cIndex;
    
    private uint fetchCount = 0;
    
    private bit prepared = false;
    private bit executed = false;
    private bit executedDirectly = false;
    
    
    /*! \brief Diagnostics message from the last odbc call that returned SQL_SUCCESS_WITH_INFO
    */
    public OdbcMessage lastMessage;
    
    /*! \brief Return code from the last API call
     *
     * If this is set to SQL_SUCCESS_WITH_INFO, the 
     * info message is available in lastMessage.
     *
     *
    */
    public RETCODE lastRetcode;
    

    /*! \brief Read/write: Automatic column binding
     *
     * This value is used by the class internally 
     * on the first fetch call after a new query.
     *
     * On the first fetch, if bindAll is true,
     * all columns will be bound.
     * Columns not defined by setBinding will be bound to a default target type.
     * 
     * If bindAll is false, only those columns defined with the setBinding functions 
     * will be bound. All other columns will remain unbound.
     * 
     * 
     * Changes to this value won't be in effect between subsequent fetch'es after the first fetch
     *
     * Closing the result or executing a new query resets this value to true. The bindAll behaviour 
     * must be set between the query execution and the first call to fetch.
     * 
     *
     * Default of bindAll is true.
     *
    */

    public bit bindAll = true;
    
    
    
    private this(OdbcConnection dbc)
    {
        this.dbc = dbc;
        lastMessage = new OdbcMessage;
        dbc.checkRetcode(SQLAllocHandle(SQL_HANDLE_STMT, dbc.hdbc, &hstmt)
            , "SQLAllocHandle");
        
        next = dbc.reslist;
        if(next) next.previous = this;
        dbc.reslist = this;
    }
    
    private this(OdbcConnection dbc, char[] sql)
    {
        this(dbc);
        execDirect(sql);
        executedDirectly = true;
    }
        
    
    ~this()
    {
        
        //writefln("result destructor; next: %d", next);
        
        if(previous) {
            previous.next = next;
            if(next) next.previous = previous;
        } else {
            if(next) next.previous = null;
            dbc.reslist = next;
        }
        
        try {
            
            if(executedDirectly || executed || cbindings.length > 0 || pbindings.length > 0)
                close();
            
            checkRetcode(SQLFreeHandle(SQL_HANDLE_STMT, hstmt), "SQLFreeHandle");
        
        } catch(SqlException e) {}

        //writefln("/result destructor");
    }
    

    /*! \brief The parent connections environment.
     *
     * shortcut for result.connection().environment()
     */
    
    public OdbcEnvironment environment()
    {
        return dbc.environment();
    }
    
    /*! \brief The parent connection.
     *
     */
    
    public OdbcConnection connection()
    {
        return dbc;
    }
    

    /*! \brief The underlying hstmt for operations not provided by this class.
     *
     */
    
    public HSTMT handle()
    {
        return hstmt;
    }
    
    
    /*! \brief Prepares a SQL statement for later execution.
     */
    
    public void prepare(char[] query) {
    
        if(executed || executedDirectly)
            close();
        
        checkRetcode(SQLPrepare(
            hstmt,
            cast(SQLCHAR*) toStringz(query),
            query.length
            ), "SQLPrepare");
    }
    
    
    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     */
    public void setInput(int num, long param, int paramType = SQL_BIGINT) {
        setInputBuffer(num, D_LONG, &param, param.sizeof, paramType);
    }
    
    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     */
    public void setInput(int num, int param, int paramType = SQL_INTEGER) {
        setInputBuffer(num, D_INT, &param, param.sizeof, paramType);
    }
    
    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     */
    public void setInput(int num, short param, int paramType = SQL_SMALLINT) {
        setInputBuffer(num, D_SHORT, &param, param.sizeof, paramType);
    }
    
    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     */
    public void setInput(int num, double param, int paramType = SQL_DOUBLE) {
        setInputBuffer(num, D_DOUBLE, &param, param.sizeof, paramType);
    }
    
    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     */
    public void setInput(int num, float param, int paramType = SQL_REAL) {
        setInputBuffer(num, D_FLOAT, &param, param.sizeof, paramType);
    }
    
    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     *
     */
    public void setInput(int num, char[] param, int paramType = SQL_VARCHAR, int bufLen = 0) {
        setInputBuffer(num, D_CHAR, cast(void*)param, param.length, paramType, bufLen);
    }

    /*! \brief Sets an input parameter for a prepared statement
     *
     * Parameter index numbers start at 0 for the leftmost parameter.
     *
     * This function is called setInputw, otherwise the compiler complains about
     * ambiguous overload with setInput(... char[] ...)
     * 
     */
    public void setInputw(int num, wchar[] param, int paramType = SQL_WVARCHAR, int bufLen = 0) {
        setInputBuffer(num, D_WCHAR, cast(void*)param, wchar.sizeof * param.length, paramType, bufLen);
    }
    
    
    /*! \if never 
    */
    
    private void setInputBuffer(int num, int valueType, void* param, uint paramLen, SQLINTEGER paramType, uint minBufLen = 0)
    in {
        assert(minBufLen == 0 || minBufLen >= paramLen);
        
    }
    body {
        /* sets the input parameter buffer for a column to the value submitted by the application.
         * allocs, reallocs and binds the parameter as necessary.
         */
        
        if(minBufLen == 0) minBufLen = paramLen;
        
        if(pbindings.length < num + 1) {
            pbindings.length = num + 1;
        }

        if(pbindings[num]) {
        
            if(minBufLen > pbindings[num].binding.bufLen) {
            
                pbindings[num].binding.bound = false;
                reallocBinding(&pbindings[num].binding, minBufLen);
            
            } else if(pbindings[num].binding.bound && (
                            pbindings[num].valueType != valueType 
                            || pbindings[num].paramType != paramType
                            )) {
                
                pbindings[num].binding.bound = false;
            }
            
        } else {
            
            pbindings[num] = new ParamBinding;
            allocBinding(&pbindings[num].binding, minBufLen);
        }
        
        if(!pbindings[num].binding.bound) {
            bindParameter(SQL_PARAM_INPUT, num, valueType, paramType);
        }
        
        pbindings[num].binding.buffer[0..paramLen] = param[0..paramLen];
        *pbindings[num].binding.StrLen_or_IndPtr = paramLen;
        
    }
    
    private void bindParameter(SQLSMALLINT iotype, int num, SQLSMALLINT valueType, SQLSMALLINT paramType)
    in {
        assert(num < pbindings.length);
        assert(pbindings[num]);
        assert(pbindings[num].binding.allocated);
    }
    body {
        
        checkRetcode(SQLBindParameter(
            hstmt,
            num + 1,
            iotype,
            valueType,
            paramType,
            pbindings[num].binding.bufLen,
            2,
            pbindings[num].binding.buffer,
            pbindings[num].binding.bufLen,
            pbindings[num].binding.StrLen_or_IndPtr
            ), "SQLBindParameter");

    }
    
    /*! \endif
    */

    
    /*! \brief Executes a prepared statement for this result.
     *
     * \warning
     * If the result was bound to a previous query, all resources related to that query will be freed
     * For instance, a buffer retrieved with rawBuffer will be freed.
     *
     */

     public void execute()
     {
         checkRetcode(SQLExecute(hstmt), "SQLExecute");
         executed = true;
     }
    

    /*! \brief Executes a query for this result.
     *
     * \warning
     * If the result was bound to a previous query, all resources related to that query will be freed
     * For instance, a buffer retrieved with rawBuffer will be freed.
     *
     */
    

    public void execDirect(char[] sql)
    {   
        
        if(executedDirectly || executed || prepared) close();
        
        checkRetcode(SQLExecDirect(hstmt, toStringz(sql), SQL_NTS), "SQLEcexDirect");
        executedDirectly = true;
        
        short ccount = 0;
        RETCODE rc = checkRetcode(SQLNumResultCols(hstmt, &ccount), "SQLNumResultCols");
        
        if(ccount == 0) {
        
        } else {
            
            cspecs.length = ccount;
            cbindings.length = ccount;
            getColumnSpecs();
            
        }
        
    }
    
    /*
     *
     * Column attributes
     *
     *
     */
    
    /*! \brief Column count - 0 for not row source type results 
     *
     * Number of columns in the result.
     * If the the query didn't produce a row source,
     * columnCount returns 0.
     *
     * Column index starts at 0 with the leftmost column.
     *
     */
    
    public uint columnCount() 
    {
        return cspecs.length;
    }
     
    
    /*! \brief Array of column names, sorted by column index
     *
     * An array of strings holding the column names.
     * 0 is the leftmost column, length-1 the rightmost.
     *
     *
     */
    
    public char[][] columns()
    {
        assert(cspecs.length);
        
        char[][] columns;
        columns.length = cspecs.length;
        
        int i = 0;
        foreach(ColumnSpec* ca; cspecs) {
            columns[i++] = ca.name;
        }
        
        return columns;
    }
    
    /* column specification. returns a pointer. */
    
    /*! \brief Column attributes specification
     *
     * This returns a struct holding information aboute a single column:
     * - .name - name of the column (char[])
     * - .type - column type (char[])
     * - .csize - size of the column data (ushort)
     * - .digits - (ushort)
     * - .nullable - (ushort)
     * - .numericType - (ushort)
     *
     */
    
    public ColumnSpec* columnSpec(char[] column)
    {
        assert(column in cIndex);
        return columnSpec(cIndex[column]);
    }
    
    /*! \brief Column attributes specification
        
    */
    public ColumnSpec* columnSpec(uint col)
    {
        assert(col < cspecs.length);
        /*
        ColumnSpec* cs = new ColumnSpec;
        
        void[] v1 = (cast(void*)cs)[0..(*cs).sizeof];
        void[] v2 = (cast(void*)cspecs[col])[0..(*cspecs[col]).sizeof];
        
        v1[0..length] = v2[0..length];
        */
        
        return cspecs[col];
        
    }
    
    /*! \brief Sets the binding for a column
     *
     *  
     * Valid parameters:
     <pre>
         SqlResult.D_LONG
         SqlResult.D_INT
         SqlResult.D_SHORT
         
         SqlResult.D_DOUBLE
         SqlResult.D_FLOAT
         
         SqlResult.D_WCHAR
         SqlResult.D_CHAR
         
         SqlResult.UNBOUND
     </pre>
     *
     * This function sets the binding target type for a column or for all columns,
     * but it doesn't actually bind the columns.
     * The columns are bound on the first call to fetch().
     *
     *
     * Every D type is mapped to a predefined target C type. Some target types can be extracted
     * with the value functions.
     *
     
        D_LONG =   SQL_C_SBIGINT   result.vlong(col)
        D_INT =    SQL_C_SLONG     result.vint(col)
        D_SHORT =  SQL_C_SSHORT    result.vshort(col)
        D_DOUBLE = SQL_C_DOUBLE    result.vdouble(col)
        D_FLOAT =  SQL_C_FLOAT     result.vfloat(col)
        D_CHAR =   SQL_C_CHAR      result.string(col) result.stringz(col)
        D_WCHAR =  SQL_C_WCHAR     result.wstring(col)
     
     *
     *
     * Default target types for column bindings are the default target types from the ODBC specs
     * with the following exceptions:
     <pre>
        SQL_BIGINT:         D_LONG (SQL_C_SBIGINT) - odbc default is SQL_C_CHAR
        SQL_TYPE_DATE:      D_CHAR (SQL_C_CHAR)
        SQL_TYPE_TIME:      D_CHAR (SQL_C_CHAR)
        SQL_TYPE_TIMESTAMP: D_CHAR (SQL_C_CHAR)
     </pre>
     
     * SqlResult.UNBOUND causes the column not to be bound.
     * \note
     * If bindAll is true, all columns set to UNBOUND will be set to their default types on the first fetch.
     * After the first fetch, a column set to UNBOUND stays unbound even if bindAll is true.
     * 
     * If the column is already bound it will be unbound.
     * \warning
     * Allocated buffer for the column will be freed.
     *
     *
     */
    
    public void setBinding(uint col, int dType)
    {
        assert(col < cbindings.length);
        
        cbindings[col].targetType = dType; /* mapped c types */
        if(fetchCount > 0)
            bindColumn(col); /* rebind column if this is called after the first fetch */
    }
     
    /*! \brief Sets the binding for a column identified by column name
    */
    public void setBinding(char[] column, int dType)
    {
        assert(column in cIndex);
        setBinding(cIndex[column], dType);
    }
     
    /*! \brief Sets the binding for all columns
    */
    public void setBinding(int dType)
    {

        foreach(ColumnBinding* cb; cbindings)
            cb.targetType = dType; /* mapped c types */
        
        if(fetchCount != 0) {

            if(dType == UNBOUND) {
        
                checkRetcode(SQLFreeStmt(
                    hstmt,
                    SQL_UNBIND
                    ), "SQLFreeStmt");
                    
                foreach(ColumnBinding* cb; cbindings) {
                    cb.binding.bound = false;
                    if(cb.binding.allocated)
                        freeBinding(&cb.binding);
                }

                    
            } else {
                bindColumns();
            }
        } 
    }
     
    
    /*! \brief Sets the target c type for a column
     * 
     * 
     * This function can be called on any individual column to set
     * it's target c type.
     * 
     *
     * Valid arguments are the SQL_C_* constants.
     *
     *
     */ 
     
    public void setTargetC(uint col, SQLINTEGER targetType)
    {
        assert(col < cbindings.length);
        
        cbindings[col].targetType = targetType;
        
        if(fetchCount > 0)
            bindColumn(col); /* rebind column if this is called after the first fetch */
    }
    
    
    
    /*! \brief Fetches the next row into the buffer.
     * 
     * Returns true if there was a new row to fetch, false otherwise.
     *
     *
     *
     */
    
    public bit fetch()
    {
        if(fetchCount == 0) {
            if(bindAll) {
                for(int col = 0; col < cbindings.length; col++) {
                    if(cbindings[col].targetType == UNBOUND) 
                        cbindings[col].targetType = defaultTarget(cspecs[col].numericType);
                }
            }
            bindColumns();
        } 
        fetchCount++;

        RETCODE rc = checkRetcode(SQLFetch(hstmt), "SQLFetch");
        
        if(rc == SQL_NO_DATA_FOUND)
            return false;
        
        return true;
        
    }
    
    
    
    /*
    *
    * private functions and templates for access to column values
    *
    *
    */
    
    private bit _checkTarget(int col, int dType)
    {
        return checkTarget(dType, cspecs[col].numericType, cbindings[col].targetType ? cbindings[col].targetType : defaultTarget(cspecs[col].numericType));
    }
    private void _checkTargetErr(int col, int dType)
    {
        SQLINTEGER targetType = cbindings[col].targetType ? cbindings[col].targetType : defaultTarget(cspecs[col].numericType);
        
        if(!checkTarget(dType, cspecs[col].numericType, targetType)) {
            
            char[] errmsg = "Incompatible value function for column " ~ .toString(col) ~ ". ";
            char[] oktypes;
            
            int type = cspecs[col].numericType;
            
            if(checkTarget(D_LONG, type, targetType))
                oktypes ~= " result.vlong.";
                
            if(checkTarget(D_INT, type, targetType))
                oktypes ~= " result.vint.";
                
            if(checkTarget(D_SHORT, type, targetType))
                oktypes ~= " result.vshort.";
                
            if(checkTarget(D_DOUBLE, type, targetType))
                oktypes ~= " result.vdouble.";
                
            if(checkTarget(D_FLOAT, type, targetType))
                oktypes ~= " result.vfloat.";
                
            if(checkTarget(D_CHAR, type, targetType))
                oktypes ~= " result.string.";
                
            if(checkTarget(D_WCHAR, type, targetType))
                oktypes ~= " result.wstring.";
                
            if(oktypes.length == 0)
                errmsg ~= "Target type not supported. Use rawBuffer to retrieve this column.";
            else
                errmsg ~= "Compatible value function is" ~ oktypes;
            
            throw new Exception(errmsg);
        }
    }


    private template value(int D_TYPE, RET_TYPE)
    {
        RET_TYPE val(uint col)
        in {
            assert(col < cbindings.length);
            assert(cbindings[col].binding.bound);
            
            _checkTargetErr(col, D_TYPE);
        }
        body {
            return *(cast(RET_TYPE*) (cbindings[col].binding.buffer));
        }
        RET_TYPE val(char[] column)
        in {
            assert(column in cIndex);
            assert(cbindings[cIndex[column]].binding.bound);
            _checkTargetErr(cIndex[column], D_TYPE);
        }
        body {
            return *(cast(RET_TYPE*) (cbindings[cIndex[column]].binding.buffer));
        }
    }
    
    private template value_char(int D_TYPE, RET_TYPE)
    {
        RET_TYPE[] val(uint col)
        in {
            assert(col < cbindings.length);
            assert(cbindings[col].binding.bound);
            _checkTargetErr(col, D_TYPE);
        }
        body {
            
            if(*cbindings[col].binding.StrLen_or_IndPtr == SQL_NULL_DATA || *cbindings[col].binding.StrLen_or_IndPtr == 0) 
                return "";
            
            void[] retval;
            retval.length = *cbindings[col].binding.StrLen_or_IndPtr;
            retval[0..length] = ((cast(void*)cbindings[col].binding.buffer)[0..*cbindings[col].binding.StrLen_or_IndPtr]);
            return cast(RET_TYPE[]) retval;
        }
        RET_TYPE[] val(char[] column)
        in {
            assert(column in cIndex);
            
        }
        body {
            return val(cIndex[column]);
        }
    }
    
    /*
     *
     * getData for unbound columns
     *
     *
     */ 

    private template getData(RET_TYPE, int SQL_C_TYPE) 
    { 
        RET_TYPE get(char[] column)
        in { 
            assert(column in cIndex);
        } 
        body {
            return get(cIndex[column]);
        }
        
        RET_TYPE get(int col)
        in { 
            assert(fetchCount > 0);
            assert(col < cbindings.length);
            assert(!cbindings[col].binding.bound);
        } 
        body {
            
            RET_TYPE targetValue;
            SQLINTEGER StrLen_or_Ind;
            
            checkRetcode(SQLGetData(
                hstmt,
                col + 1,
                SQL_C_TYPE,
                &targetValue,
                0,
                &StrLen_or_Ind
                ), "SQLGetData");
            
            return targetValue;
        }
    }
        
    
    private template getData_char(RET_TYPE, int SQL_C_TYPE) 
    { 
        RET_TYPE[] get(char[] column)
        in { 
            assert(column in cIndex);
        } 
        body {
            return get(cIndex[column]);
        }
        
        RET_TYPE[] get(int col)
        in { 
            assert(fetchCount > 0);
            assert(col < cbindings.length);
            assert(!cbindings[col].binding.bound);
        } 
        body {
            
            void[] targetValue;
            
            targetValue.length = RET_TYPE.sizeof * (cspecs[col].csize + 1);
            
            SQLINTEGER StrLen_or_Ind;
            
            void[] buffer = targetValue[0..length];
            
            while(checkRetcode(SQLGetData(
                        hstmt,
                        col + 1,
                        SQL_C_TYPE,
                        buffer,
                        buffer.length,
                        &StrLen_or_Ind
                        ), "SQLGetData") == SQL_SUCCESS_WITH_INFO) {
            
                
                writefln(lastMessage.toString());
                assert(0); /* waiting for this to happen... */
                
                uint tmp = targetValue.length;
                targetValue.length = StrLen_or_Ind;
                buffer = targetValue[tmp..length];
                            
            }
            
            RET_TYPE[] retval;
            retval.length = StrLen_or_Ind / RET_TYPE.sizeof;
            
            (cast(void[])retval)[0..length] = targetValue[0..StrLen_or_Ind];
            
            return retval;
        }
    }
    
    private template values(int D_TYPE, RET_TYPE) 
    {
     
        public RET_TYPE[int] cvals()
        {
            assert(cbindings.length > 0);
            
            RET_TYPE[int] val;
            
            for(int col = 0; col < cbindings.length; col++){
                /* ColumnBinding* cb = cbindings[col]; */
                if(_checkTarget(col, D_TYPE)) {
                    
                    val[col] = value!(D_TYPE, RET_TYPE).val(col);
                }
            }
            
            return val;
        }
        public RET_TYPE[char[]] fvals()
        {
            assert(cbindings.length > 0);
            
            RET_TYPE[char[]] val;
            for(int col = 0; col < cbindings.length; col++){
                ColumnBinding* cb = cbindings[col];
                if(_checkTarget(col, D_TYPE)) {
                    
                    val[cspecs[col].name] = value!(D_TYPE, RET_TYPE).val(col);
                }
            }
            
            return val;
        }
    }
    private template values_char(int D_TYPE, RET_TYPE) 
    {
     
        public RET_TYPE[][int] cvals()
        {
            assert(cbindings.length > 0);
            
            RET_TYPE[][int] val;
            
            for(int col = 0; col < cbindings.length; col++){
                ColumnBinding* cb = cbindings[col];
                if(_checkTarget(col, D_TYPE)) {
                    
                    val[col] = value_char!(D_TYPE, RET_TYPE).val(col);
                }
            }
            
            return val;
        }
        public RET_TYPE[][char[]] fvals()
        {
            assert(cbindings.length > 0);
            
            RET_TYPE[][char[]] val;
            for(int col = 0; col < cbindings.length; col++){
                /* ColumnBinding* cb = cbindings[col]; */
                if(_checkTarget(col, D_TYPE)) {
                    
                    val[cspecs[col].name] = value_char!(D_TYPE, RET_TYPE).val(col);
                }
            }
            
            return val;
        }
    }


    /*
     *
     *
     * public access to column values
     *
     *
     */
    
    
    
    /*! \brief Returns true if the column contains a NULL value.
     */

     public bit isNull(uint col)
    {
        assert(fetchCount > 0);
        assert(col < cbindings.length);
        assert(cbindings[col].binding.bound);
        
        return *cbindings[col].binding.StrLen_or_IndPtr == SQL_NULL_DATA;
    }

    /*! \brief Returns true if the column contains a NULL value.
     */
        public bit isNull(char[] column)
    {
        assert(fetchCount > 0);
        assert(column in cIndex);
        assert(cbindings[cIndex[column]].binding.bound);
        
        return *cbindings[cIndex[column]].binding.StrLen_or_IndPtr == SQL_NULL_DATA;
    }


    /*
     *
     * Retrieving values from bound columns
     *
     *
     */ 

     

                    
    
    /*! \brief char[] string(int col); char[] string(char[] column); 
     *
     * Retrieves a column value as a string.
     *
     * The value functions attempt to retrieve the buffer for a column
     * into each function's return type.
     *
     * In contract:
     *
     * If the c target type is incompatible, an Exception is thrown.
     *
     * See d type to sql c type mapping under setBinding()
     *
     *
     */
     
    public alias value_char!(D_CHAR, char).val string;
    

    /*! \brief wchar[] wstring(int col); wchar[] wstring(char[] column); 
     */
    public alias value_char!(D_WCHAR, wchar).val wstring;


    /*! \brief long vlong(int col); long vlong(char[] column); 
     */
    public alias value!(D_LONG, long).val vlong;

    
    /*! \brief int vint(int col); int vint(char[] column); 
     */
    public alias value!(D_INT, int).val vint;
    
    /*! \brief short vshort(int col); short vshort(char[] column); 
     */
    public alias value!(D_SHORT, short).val vshort;

    /*! \brief double vdouble(int col); double vdouble(char[] column); 
     */
    public alias value!(D_DOUBLE, double).val vdouble;

    /*! \brief float vfloat(int col); float vfloat(char[] column); 
     */
    public alias value!(D_FLOAT, float).val vfloat;

    
    /*! \brief Returns a null terminated c string from the buffer
     */
    public char* stringz(int col)
    {
        return .toStringz(string(col));
    }
    
    /*! \brief Returns a null terminated c string from the buffer
     */
    public char* stringz(char[] column)
    {
        return .toStringz(string(column));
    }
    


    /*! \brief Returns a pointer to the buffer bound to a column.
     *
     *
     * SQLPOINTER TargetValuePtr points to the raw buffer. The buffer is not copied.
     * SQLINTEGER* StrLen_or_IndPtr points to the string length or indication buffer
     *
     * The buffer pointers remain valid after a new fetch, containing the new values.
     *
     * \warning
     * The buffer and the integer are malloc'd and will be free'd by the result object's destructor
     * or after a call to setBinding for this column.
     * 
     *
     */

     public void rawBuffer(in int col, out SQLPOINTER TargetValuePtr, out SQLINTEGER* StrLen_or_IndPtr)
    {
        assert(fetchCount > 0);
        assert(col < cbindings.length);
        
        TargetValuePtr = cbindings[col].binding.buffer;
        StrLen_or_IndPtr = cbindings[col].binding.StrLen_or_IndPtr;
    }
     
     
     
     
     
    /*! \brief char[][int] strings() - Returns an indexed associative array from the current row.
     *
     * Returns an associative array of all compatible columns of the current row.
     * The index is the column index. Missing indexes are of incompatible type.
     *
     */
     public alias values_char!(D_CHAR, char).cvals strings;

    /*! \brief char[][char[]] stringsN() - Returns a named associative array from the current row.
     *
     * Returns an associative array of all compatible columns of the current row.
     * The index is the column name. Missing column names are of incompatible type.
     *
     */
     public alias values_char!(D_CHAR, char).fvals stringsN;

     
     
    /*! \brief wchar[][int] wstrings(); wchar[][char[]] wstringsN()
     */
     public alias values_char!(D_WCHAR, wchar).cvals wstrings;
     public alias values_char!(D_WCHAR, wchar).fvals wstringsN;

     
    /*! \brief long[int] vlongs(); long[char[]] vlongsN()
     */
     public alias values!(D_LONG, long).cvals vlongs;
     public alias values!(D_LONG, long).fvals vlongsN;


     
     /*! \brief int[int] vints(); int[char[]] vintsN()
     */
     public alias values!(D_INT, int).cvals vints;
     public alias values!(D_INT, int).fvals vintsN;


     
     /*! \brief short[int] vshorts(), short[char[]] vshortsN()
     */
     public alias values!(D_SHORT, short).cvals vshorts;
     public alias values!(D_SHORT, short).fvals vshortsN;

     
     
     /*! \brief double[int] vdoubles(); double[char[]] vdoublesN()
     */
     public alias values!(D_DOUBLE, double).cvals vdoubles;
     public alias values!(D_DOUBLE, double).fvals vdoublesN;
     
     
     
     /*! \brief float[int] vfloats(), float[char[]] vfloatsN()
     */
     public alias values!(D_DOUBLE, float).cvals vfloats;
     public alias values!(D_DOUBLE, float).fvals vfloatsN;

     

     
    /*! \brief wstringData(int col); wstringData(char[] column)
     * Retrieves a wstring data value from an unbound column 
    */
    public alias getData_char!(wchar, SQL_C_WCHAR).get wstringData;
        
    /*! \brief stringData(int col); stringData(char[] column)
    Retrieves a string data value from an unbound column 
    */
    public alias getData_char!(char, SQL_C_CHAR).get stringData;
        

    /*! \brief longData(int col); longData(char[] column)
    Retrieves a long data value from an unbound column 
    */
    public alias getData!(long, SQL_C_LONG).get longData;
    
    /*! \brief intData(int col); intData(char[] column)
    Retrieves a int data value from an unbound column 
    */
    public alias getData!(int, SQL_C_SHORT).get intData;
        
    /*! \brief shortData(int col); shortData(char[] column)
    Retrieves a short data value from an unbound column 
    */
    public alias getData!(short, SQL_C_SHORT).get shortData;
        
    
    
    /*! \brief Closes the result. The result can be reexecuted with a new sql statement
    */
    public void close()
    {
        
        foreach(ColumnBinding* cb; cbindings) {
            if(cb.binding.allocated)
                freeBinding(&cb.binding);
        }
        
        foreach(ParamBinding* pb; pbindings) {
            if(pb && pb.binding.allocated)
                freeBinding(&pb.binding);
        }
        
        checkRetcode(SQLFreeStmt(
            hstmt,
            SQL_UNBIND
            ), "SQLFreeStmt");
        
        checkRetcode(SQLFreeStmt(
            hstmt,
            SQL_RESET_PARAMS
            ), "SQLFreeStmt");
        
        
        foreach(char[] key; cIndex.keys)
            delete cIndex[key];
        
        cbindings.length = 0;
        pbindings.length = 0;
        cspecs.length = 0;
        fetchCount = 0;
        bindAll = true;
        
        checkRetcode(SQLFreeStmt(
            hstmt,
            SQL_CLOSE
            ), "SQLFreeStmt");

        prepared = false;
        executed = false;
        executedDirectly = false;
        
    }
    
    /*! \brief Deletes this object.
    */
    public void free()
    {
        delete this;
    }
    
    
    
    private void getColumnSpecs()
    {
        
        char[256] buffer;
        
        for(int i = 0; i < cspecs.length; i++) {
            
            short retLen = 0;
            cspecs[i] = new ColumnSpec();
            ColumnSpec* cs = cspecs[i];
            
            RETCODE rc = checkRetcode(SQLDescribeCol(
                hstmt,
                i + 1,
                buffer,
                buffer.length,
                &retLen,
                &(cs.numericType),
                &(cs.csize),
                &(cs.digits),
                &(cs.nullable)
                ), "SQLDescribeCol");
            
            cs.name.length = retLen;
            cs.name[0 .. length] = buffer[0 .. retLen];
               
            checkRetcode(SQLColAttribute (
                hstmt,
                i + 1,
                SQL_DESC_TYPE_NAME,
                buffer,
                buffer.length,
                &retLen,
                null
                ), "SQLColAttribute");  
                
            cs.type.length = retLen;
            cs.type[0 .. length] = buffer[0 .. retLen];

            checkRetcode(SQLColAttribute (
                hstmt,
                i + 1,
                SQL_DESC_OCTET_LENGTH,
                null,
                0,
                null,
                &(cs.octetLength)
                ), "SQLColAttribute");  
                
            cIndex[cs.name] = i;
                        
            cbindings[i] = new ColumnBinding;
            
            //writefln("-- %s - %d %d %d %d ---- ", cs.name, cs.type, cs.csize, cs.digits, cs.nullable);
            
            
        }
    }
    
    
    private void bindColumns()
    {
        
        for(uint col = 0; col < cbindings.length; col++) {
            if(cbindings[col].targetType != UNBOUND || cbindings[col].binding.bound) 
                bindColumn(col);
        }
    }
    
    private void bindColumn(uint col) {

        ColumnBinding* cb = cbindings[col];
        ColumnSpec* cs = cspecs[col];
        
        assert(cb.targetType != UNBOUND || cb.binding.bound);
        
        uint ptrSize;
        
        if(cb.targetType == UNBOUND) {
            ptrSize = 0;
            cb.binding.buffer = null;
        } else {
        
            ptrSize = cb.targetType == SQL_C_WCHAR ?
                    wchar.sizeof * cs.csize + 1
                    : (
                    cb.targetType == SQL_C_CHAR ?
                        cs.csize + 1
                        : cs.octetLength
                    );
        
                    
            if((cs.numericType == 93))
                /* sql server datetime columns return timestamp (93) format with milliseconds. 
                those need more space. */
                ptrSize += 8; /* room for sql server milliseconds */
        }
        
        //writefln("col %d targettype %d size %d", col, targetType, ptrSize);
        
        assert(cb.targetType == UNBOUND || ptrSize > 0);
        
        if(cb.binding.allocated) {
            if(cb.binding.bufLen < ptrSize)
                reallocBinding(&cb.binding, ptrSize);
        } else {
            allocBinding(&cb.binding, ptrSize);
        }
            
        checkRetcode(SQLBindCol(
           hstmt,
           col + 1,
           cb.targetType,
           cb.binding.buffer,
           cb.binding.bufLen,
           cb.binding.StrLen_or_IndPtr
           ), "SQLBindCol"); 
            
        //writefln("bound %d targettype %d octet %d ptrsize %d", col, targetType, cs.octetLength, ptrSize);

        cb.binding.bound = cb.targetType != UNBOUND;
        
    }
    
    
    private void allocBinding(Binding* b, uint bufLen)
    in {
        assert(!b.bound);
        assert(!b.allocated);
        assert(bufLen);
    }
    body {
        void* p = std.c.stdlib.malloc(bufLen);
        
        if(p == null) {
            throw new Exception("Out of memory"); 
            /* don't know if the gc has memory for that exception... 
               if not, gc handles the error */
        }
        
        b.buffer = cast(SQLPOINTER) p;
        
        p = std.c.stdlib.malloc(b.StrLen_or_IndPtr.sizeof);

        if(p == null) {
            std.c.stdlib.free(b.buffer);
            throw new Exception("Out of memory");
        }
        
        b.StrLen_or_IndPtr = cast(SQLINTEGER*) p;
        b.bufLen = bufLen;
        
        b.allocated = true;
    }

    private void reallocBinding(Binding* b, uint bufLen)
    in {
        assert(b.allocated);
        assert(bufLen > b.bufLen);
    }
    body {
        
        void* p = std.c.stdlib.realloc(b.buffer, bufLen);
        
        if(p == null)
            throw new Exception("Out of memory"); /* probably there won't be memory for that exception? */
        
        b.buffer = cast(SQLPOINTER) p;
        b.bufLen = bufLen;
        
    }

    private void freeBinding(Binding* b)
    in {
        assert(b.allocated);
    }
    body {
        std.c.stdlib.free(b.buffer);
        std.c.stdlib.free(b.StrLen_or_IndPtr);
        b.allocated = false;
    }
    
    private RETCODE checkRetcode(RETCODE rc, char[] msg)
    {
        return lastRetcode = SqlException.checkRetcode(rc, msg, hstmt, SQL_HANDLE_STMT, lastMessage);
    }

    
}