insert.c 6.68 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * Implementation of the Microsoft Installer (msi.dll)
 *
 * Copyright 2004 Mike McCormack for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 */

#include <stdarg.h>

#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "msi.h"
#include "msiquery.h"
#include "objbase.h"
#include "objidl.h"
#include "msipriv.h"
#include "winnls.h"

#include "query.h"

36
WINE_DEFAULT_DEBUG_CHANNEL(msidb);
37 38 39 40 41 42 43 44 45


/* below is the query interface to a table */

typedef struct tagMSIINSERTVIEW
{
    MSIVIEW          view;
    MSIDATABASE     *db;
    BOOL             bIsTemp;
46
    MSIVIEW         *sv;
47
    column_info     *vals;
48 49 50 51 52 53 54 55 56 57 58
} MSIINSERTVIEW;

static UINT INSERT_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;

    TRACE("%p %d %d %p\n", iv, row, col, val );

    return ERROR_FUNCTION_FAILED;
}

59
/*
60
 * msi_query_merge_record
61 62 63 64
 *
 * Merge a value_list and a record to create a second record.
 * Replace wildcard entries in the valuelist with values from the record
 */
65
MSIRECORD *msi_query_merge_record( UINT fields, const column_info *vl, MSIRECORD *rec )
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
{
    MSIRECORD *merged;
    DWORD wildcard_count = 1, i;

    merged = MSI_CreateRecord( fields );
    for( i=1; i <= fields; i++ )
    {
        if( !vl )
        {
            TRACE("Not enough elements in the list to insert\n");
            goto err;
        }
        switch( vl->val->type )
        {
        case EXPR_SVAL:
81
            TRACE("field %d -> %s\n", i, debugstr_w(vl->val->u.sval));
82 83 84 85 86 87 88 89
            MSI_RecordSetStringW( merged, i, vl->val->u.sval );
            break;
        case EXPR_IVAL:
            MSI_RecordSetInteger( merged, i, vl->val->u.ival );
            break;
        case EXPR_WILDCARD:
            if( !rec )
                goto err;
90
            MSI_RecordCopyField( rec, wildcard_count, merged, i );
91 92 93 94 95 96 97 98 99 100 101 102 103 104
            wildcard_count++;
            break;
        default:
            ERR("Unknown expression type %d\n", vl->val->type);
        }
        vl = vl->next;
    }

    return merged;
err:
    msiobj_release( &merged->hdr );
    return NULL;
}

105
static UINT INSERT_execute( struct tagMSIVIEW *view, MSIRECORD *record )
106 107
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
108
    UINT r, col_count = 0;
109
    MSIVIEW *sv;
110
    MSIRECORD *values = NULL;
111

112
    TRACE("%p %p\n", iv, record );
113

114 115 116 117 118
    sv = iv->sv;
    if( !sv )
        return ERROR_FUNCTION_FAILED;

    r = sv->ops->execute( sv, 0 );
119 120 121 122
    TRACE("tv execute returned %x\n", r);
    if( r )
        return r;

123
    r = sv->ops->get_dimensions( sv, NULL, &col_count );
124 125 126
    if( r )
        goto err;

127 128 129 130
    /*
     * Merge the wildcard values into the list of values provided
     * in the query, and create a record containing both.
     */
131
    values = msi_query_merge_record( col_count, iv->vals, record );
132
    if( !values )
133 134
        goto err;

135
    r = sv->ops->insert_row( sv, values, iv->bIsTemp );
136 137

err:
138 139 140
    if( values )
        msiobj_release( &values->hdr );

141
    return r;
142 143
}

144

145 146 147
static UINT INSERT_close( struct tagMSIVIEW *view )
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
148
    MSIVIEW *sv;
149 150 151

    TRACE("%p\n", iv);

152 153 154 155 156
    sv = iv->sv;
    if( !sv )
        return ERROR_FUNCTION_FAILED;

    return sv->ops->close( sv );
157 158 159 160 161
}

static UINT INSERT_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
162
    MSIVIEW *sv;
163 164 165

    TRACE("%p %p %p\n", iv, rows, cols );

166 167 168 169 170
    sv = iv->sv;
    if( !sv )
        return ERROR_FUNCTION_FAILED;

    return sv->ops->get_dimensions( sv, rows, cols );
171 172 173 174 175 176
}

static UINT INSERT_get_column_info( struct tagMSIVIEW *view,
                UINT n, LPWSTR *name, UINT *type )
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
177
    MSIVIEW *sv;
178 179 180

    TRACE("%p %d %p %p\n", iv, n, name, type );

181 182 183 184 185
    sv = iv->sv;
    if( !sv )
        return ERROR_FUNCTION_FAILED;

    return sv->ops->get_column_info( sv, n, name, type );
186 187
}

188
static UINT INSERT_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
189 190 191
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;

192
    TRACE("%p %d %p\n", iv, eModifyMode, rec );
193 194 195 196 197 198 199

    return ERROR_FUNCTION_FAILED;
}

static UINT INSERT_delete( struct tagMSIVIEW *view )
{
    MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
200
    MSIVIEW *sv;
201 202 203

    TRACE("%p\n", iv );

204 205 206
    sv = iv->sv;
    if( sv )
        sv->ops->delete( sv );
207
    msiobj_release( &iv->db->hdr );
208
    msi_free( iv );
209 210 211 212

    return ERROR_SUCCESS;
}

213 214 215 216 217 218 219 220
static UINT INSERT_find_matching_rows( struct tagMSIVIEW *view, UINT col,
    UINT val, UINT *row, MSIITERHANDLE *handle )
{
    TRACE("%p, %d, %u, %p\n", view, col, val, *handle);

    return ERROR_FUNCTION_FAILED;
}

221

222
static const MSIVIEWOPS insert_ops =
223 224 225 226
{
    INSERT_fetch_int,
    NULL,
    NULL,
227
    NULL,
228
    NULL,
229
    NULL,
230 231 232 233 234
    INSERT_execute,
    INSERT_close,
    INSERT_get_dimensions,
    INSERT_get_column_info,
    INSERT_modify,
235
    INSERT_delete,
236 237 238
    INSERT_find_matching_rows,
    NULL,
    NULL,
239
    NULL,
240
    NULL,
241 242
};

243
static UINT count_column_info( const column_info *ci )
244 245 246 247 248 249 250
{
    UINT n = 0;
    for ( ; ci; ci = ci->next )
        n++;
    return n;
}

251
UINT INSERT_CreateView( MSIDATABASE *db, MSIVIEW **view, LPCWSTR table,
252
                        column_info *columns, column_info *values, BOOL temp )
253 254
{
    MSIINSERTVIEW *iv = NULL;
255 256
    UINT r;
    MSIVIEW *tv = NULL, *sv = NULL;
257 258 259

    TRACE("%p\n", iv );

260 261 262 263
    /* there should be one value for each column */
    if ( count_column_info( columns ) != count_column_info(values) )
        return ERROR_BAD_QUERY_SYNTAX;

264 265 266 267 268 269 270 271 272 273 274
    r = TABLE_CreateView( db, table, &tv );
    if( r != ERROR_SUCCESS )
        return r;

    r = SELECT_CreateView( db, &sv, tv, columns );
    if( r != ERROR_SUCCESS )
    {
        if( tv )
            tv->ops->delete( tv );
        return r;
    }
275

276
    iv = msi_alloc_zero( sizeof *iv );
277 278
    if( !iv )
        return ERROR_FUNCTION_FAILED;
279

280 281
    /* fill the structure */
    iv->view.ops = &insert_ops;
282
    msiobj_addref( &db->hdr );
283 284 285
    iv->db = db;
    iv->vals = values;
    iv->bIsTemp = temp;
286
    iv->sv = sv;
287 288 289 290
    *view = (MSIVIEW*) iv;

    return ERROR_SUCCESS;
}