git.oblomov.eu Git - wine/blob - dlls/msi/insert.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2004 Mike McCormack for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * 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 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winerror.h"
  26 #include "wine/debug.h"
  27 #include "msi.h"
  28 #include "msiquery.h"
  29 #include "objbase.h"
  30 #include "objidl.h"
  31 #include "msipriv.h"
  32 #include "winnls.h"
  33
  34 #include "query.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
  37
  38
  39 /* below is the query interface to a table */
  40
  41 typedef struct tagMSIINSERTVIEW
  42 {
  43     MSIVIEW          view;
  44     MSIVIEW         *table;
  45     MSIDATABASE     *db;
  46     BOOL             bIsTemp;
  47     MSIVIEW         *sv;
  48     column_info     *vals;
  49 } MSIINSERTVIEW;
  50
  51 static UINT INSERT_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
  52 {
  53     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
  54
  55     TRACE("%p %d %d %p\n", iv, row, col, val );
  56
  57     return ERROR_FUNCTION_FAILED;
  58 }
  59
  60 /*
  61  * msi_query_merge_record
  62  *
  63  * Merge a value_list and a record to create a second record.
  64  * Replace wildcard entries in the valuelist with values from the record
  65  */
  66 MSIRECORD *msi_query_merge_record( UINT fields, const column_info *vl, MSIRECORD *rec )
  67 {
  68     MSIRECORD *merged;
  69     DWORD wildcard_count = 1, i;
  70
  71     merged = MSI_CreateRecord( fields );
  72     for( i=1; i <= fields; i++ )
  73     {
  74         if( !vl )
  75         {
  76             TRACE("Not enough elements in the list to insert\n");
  77             goto err;
  78         }
  79         switch( vl->val->type )
  80         {
  81         case EXPR_SVAL:
  82             TRACE("field %d -> %s\n", i, debugstr_w(vl->val->u.sval));
  83             MSI_RecordSetStringW( merged, i, vl->val->u.sval );
  84             break;
  85         case EXPR_IVAL:
  86             MSI_RecordSetInteger( merged, i, vl->val->u.ival );
  87             break;
  88         case EXPR_WILDCARD:
  89             if( !rec )
  90                 goto err;
  91             MSI_RecordCopyField( rec, wildcard_count, merged, i );
  92             wildcard_count++;
  93             break;
  94         default:
  95             ERR("Unknown expression type %d\n", vl->val->type);
  96         }
  97         vl = vl->next;
  98     }
  99
 100     return merged;
 101 err:
 102     msiobj_release( &merged->hdr );
 103     return NULL;
 104 }
 105
 106 /* checks to see if the column order specified in the INSERT query
 107  * matches the column order of the table
 108  */
 109 static BOOL msi_columns_in_order(MSIINSERTVIEW *iv, UINT col_count)
 110 {
 111     LPWSTR a, b = NULL;
 112     UINT i;
 113     int res;
 114
 115     for (i = 1; i <= col_count; i++)
 116     {
 117         iv->sv->ops->get_column_info(iv->sv, i, &a, NULL, NULL, NULL);
 118         iv->table->ops->get_column_info(iv->table, i, &b, NULL, NULL, NULL);
 119
 120         res = lstrcmpW(a, b);
 121         msi_free(a);
 122         msi_free(b);
 123
 124         if (res != 0)
 125             return FALSE;
 126     }
 127
 128     return TRUE;
 129 }
 130
 131 /* rearranges the data in the record to be inserted based on column order,
 132  * and pads the record for any missing columns in the INSERT query
 133  */
 134 static UINT msi_arrange_record(MSIINSERTVIEW *iv, MSIRECORD **values)
 135 {
 136     MSIRECORD *padded;
 137     UINT col_count, val_count;
 138     UINT r, i, colidx;
 139     LPWSTR a, b = NULL;
 140     int res;
 141
 142     r = iv->table->ops->get_dimensions(iv->table, NULL, &col_count);
 143     if (r != ERROR_SUCCESS)
 144         return r;
 145
 146     val_count = MSI_RecordGetFieldCount(*values);
 147
 148     /* check to see if the columns are arranged already
 149      * to avoid unnecessary copying
 150      */
 151     if (col_count == val_count && msi_columns_in_order(iv, col_count))
 152         return ERROR_SUCCESS;
 153
 154     padded = MSI_CreateRecord(col_count);
 155     if (!padded)
 156         return ERROR_OUTOFMEMORY;
 157
 158     for (colidx = 1; colidx <= val_count; colidx++)
 159     {
 160         r = iv->sv->ops->get_column_info(iv->sv, colidx, &a, NULL, NULL, NULL);
 161         if (r != ERROR_SUCCESS)
 162             goto err;
 163
 164         for (i = 1; i <= col_count; i++)
 165         {
 166             r = iv->table->ops->get_column_info(iv->table, i, &b, NULL,
 167                                                 NULL, NULL);
 168             if (r != ERROR_SUCCESS)
 169                 goto err;
 170
 171             res = lstrcmpW(a, b);
 172             msi_free(b);
 173
 174             if (res == 0)
 175             {
 176                 MSI_RecordCopyField(*values, colidx, padded, i);
 177                 break;
 178             }
 179         }
 180
 181         msi_free(a);
 182     }
 183
 184     msiobj_release(&(*values)->hdr);
 185     *values = padded;
 186
 187     return ERROR_SUCCESS;
 188
 189 err:
 190     msiobj_release(&padded->hdr);
 191     return r;
 192 }
 193
 194 static BOOL row_has_null_primary_keys(MSIINSERTVIEW *iv, MSIRECORD *row)
 195 {
 196     UINT r, i, col_count, type;
 197
 198     r = iv->table->ops->get_dimensions( iv->table, NULL, &col_count );
 199     if (r != ERROR_SUCCESS)
 200         return FALSE;
 201
 202     for (i = 1; i <= col_count; i++)
 203     {
 204         r = iv->table->ops->get_column_info(iv->table, i, NULL, &type,
 205                                             NULL, NULL);
 206         if (r != ERROR_SUCCESS)
 207             return FALSE;
 208
 209         if (!(type & MSITYPE_KEY))
 210             continue;
 211
 212         if (MSI_RecordIsNull(row, i))
 213             return TRUE;
 214     }
 215
 216     return FALSE;
 217 }
 218
 219 static UINT INSERT_execute( struct tagMSIVIEW *view, MSIRECORD *record )
 220 {
 221     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
 222     UINT r, row = -1, col_count = 0;
 223     MSIVIEW *sv;
 224     MSIRECORD *values = NULL;
 225
 226     TRACE("%p %p\n", iv, record );
 227
 228     sv = iv->sv;
 229     if( !sv )
 230         return ERROR_FUNCTION_FAILED;
 231
 232     r = sv->ops->execute( sv, 0 );
 233     TRACE("sv execute returned %x\n", r);
 234     if( r )
 235         return r;
 236
 237     r = sv->ops->get_dimensions( sv, NULL, &col_count );
 238     if( r )
 239         goto err;
 240
 241     /*
 242      * Merge the wildcard values into the list of values provided
 243      * in the query, and create a record containing both.
 244      */
 245     values = msi_query_merge_record( col_count, iv->vals, record );
 246     if( !values )
 247         goto err;
 248
 249     r = msi_arrange_record( iv, &values );
 250     if( r != ERROR_SUCCESS )
 251         goto err;
 252
 253     /* rows with NULL primary keys are inserted at the beginning of the table */
 254     if( row_has_null_primary_keys( iv, values ) )
 255         row = 0;
 256
 257     r = iv->table->ops->insert_row( iv->table, values, row, iv->bIsTemp );
 258
 259 err:
 260     if( values )
 261         msiobj_release( &values->hdr );
 262
 263     return r;
 264 }
 265
 266
 267 static UINT INSERT_close( struct tagMSIVIEW *view )
 268 {
 269     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
 270     MSIVIEW *sv;
 271
 272     TRACE("%p\n", iv);
 273
 274     sv = iv->sv;
 275     if( !sv )
 276         return ERROR_FUNCTION_FAILED;
 277
 278     return sv->ops->close( sv );
 279 }
 280
 281 static UINT INSERT_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
 282 {
 283     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
 284     MSIVIEW *sv;
 285
 286     TRACE("%p %p %p\n", iv, rows, cols );
 287
 288     sv = iv->sv;
 289     if( !sv )
 290         return ERROR_FUNCTION_FAILED;
 291
 292     return sv->ops->get_dimensions( sv, rows, cols );
 293 }
 294
 295 static UINT INSERT_get_column_info( struct tagMSIVIEW *view,
 296                 UINT n, LPWSTR *name, UINT *type, BOOL *temporary,
 297                 LPWSTR *table_name)
 298 {
 299     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
 300     MSIVIEW *sv;
 301
 302     TRACE("%p %d %p %p %p %p\n", iv, n, name, type, temporary, table_name );
 303
 304     sv = iv->sv;
 305     if( !sv )
 306         return ERROR_FUNCTION_FAILED;
 307
 308     return sv->ops->get_column_info( sv, n, name, type, temporary, table_name );
 309 }
 310
 311 static UINT INSERT_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
 312 {
 313     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
 314
 315     TRACE("%p %d %p\n", iv, eModifyMode, rec );
 316
 317     return ERROR_FUNCTION_FAILED;
 318 }
 319
 320 static UINT INSERT_delete( struct tagMSIVIEW *view )
 321 {
 322     MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
 323     MSIVIEW *sv;
 324
 325     TRACE("%p\n", iv );
 326
 327     sv = iv->sv;
 328     if( sv )
 329         sv->ops->delete( sv );
 330     msiobj_release( &iv->db->hdr );
 331     msi_free( iv );
 332
 333     return ERROR_SUCCESS;
 334 }
 335
 336 static UINT INSERT_find_matching_rows( struct tagMSIVIEW *view, UINT col,
 337     UINT val, UINT *row, MSIITERHANDLE *handle )
 338 {
 339     TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
 340
 341     return ERROR_FUNCTION_FAILED;
 342 }
 343
 344
 345 static const MSIVIEWOPS insert_ops =
 346 {
 347     INSERT_fetch_int,
 348     NULL,
 349     NULL,
 350     NULL,
 351     NULL,
 352     NULL,
 353     INSERT_execute,
 354     INSERT_close,
 355     INSERT_get_dimensions,
 356     INSERT_get_column_info,
 357     INSERT_modify,
 358     INSERT_delete,
 359     INSERT_find_matching_rows,
 360     NULL,
 361     NULL,
 362     NULL,
 363     NULL,
 364     NULL,
 365     NULL,
 366 };
 367
 368 static UINT count_column_info( const column_info *ci )
 369 {
 370     UINT n = 0;
 371     for ( ; ci; ci = ci->next )
 372         n++;
 373     return n;
 374 }
 375
 376 UINT INSERT_CreateView( MSIDATABASE *db, MSIVIEW **view, LPCWSTR table,
 377                         column_info *columns, column_info *values, BOOL temp )
 378 {
 379     MSIINSERTVIEW *iv = NULL;
 380     UINT r;
 381     MSIVIEW *tv = NULL, *sv = NULL;
 382
 383     TRACE("%p\n", iv );
 384
 385     /* there should be one value for each column */
 386     if ( count_column_info( columns ) != count_column_info(values) )
 387         return ERROR_BAD_QUERY_SYNTAX;
 388
 389     r = TABLE_CreateView( db, table, &tv );
 390     if( r != ERROR_SUCCESS )
 391         return r;
 392
 393     r = SELECT_CreateView( db, &sv, tv, columns );
 394     if( r != ERROR_SUCCESS )
 395     {
 396         if( tv )
 397             tv->ops->delete( tv );
 398         return r;
 399     }
 400
 401     iv = msi_alloc_zero( sizeof *iv );
 402     if( !iv )
 403         return ERROR_FUNCTION_FAILED;
 404
 405     /* fill the structure */
 406     iv->view.ops = &insert_ops;
 407     msiobj_addref( &db->hdr );
 408     iv->table = tv;
 409     iv->db = db;
 410     iv->vals = values;
 411     iv->bIsTemp = temp;
 412     iv->sv = sv;
 413     *view = (MSIVIEW*) iv;
 414
 415     return ERROR_SUCCESS;
 416 }