0a1fbe6de770df8fc6fa1a1a7f86b809a8460baa
[reactos.git] / reactos / dll / win32 / 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);
118 iv->table->ops->get_column_info(iv->table, i, &b, 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);
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, NULL);
167 if (r != ERROR_SUCCESS)
168 goto err;
169
170 res = lstrcmpW(a, b);
171 msi_free(b);
172
173 if (res == 0)
174 {
175 MSI_RecordCopyField(*values, colidx, padded, i);
176 break;
177 }
178 }
179
180 msi_free(a);
181 }
182
183 msiobj_release(&(*values)->hdr);
184 *values = padded;
185
186 return ERROR_SUCCESS;
187
188 err:
189 msiobj_release(&padded->hdr);
190 return r;
191 }
192
193 static BOOL row_has_null_primary_keys(MSIINSERTVIEW *iv, MSIRECORD *row)
194 {
195 UINT r, i, col_count, type;
196
197 r = iv->table->ops->get_dimensions( iv->table, NULL, &col_count );
198 if (r != ERROR_SUCCESS)
199 return FALSE;
200
201 for (i = 1; i <= col_count; i++)
202 {
203 r = iv->table->ops->get_column_info(iv->table, i, NULL, &type, NULL);
204 if (r != ERROR_SUCCESS)
205 return FALSE;
206
207 if (!(type & MSITYPE_KEY))
208 continue;
209
210 if (MSI_RecordIsNull(row, i))
211 return TRUE;
212 }
213
214 return FALSE;
215 }
216
217 static UINT INSERT_execute( struct tagMSIVIEW *view, MSIRECORD *record )
218 {
219 MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
220 UINT r, row = -1, col_count = 0;
221 MSIVIEW *sv;
222 MSIRECORD *values = NULL;
223
224 TRACE("%p %p\n", iv, record );
225
226 sv = iv->sv;
227 if( !sv )
228 return ERROR_FUNCTION_FAILED;
229
230 r = sv->ops->execute( sv, 0 );
231 TRACE("sv execute returned %x\n", r);
232 if( r )
233 return r;
234
235 r = sv->ops->get_dimensions( sv, NULL, &col_count );
236 if( r )
237 goto err;
238
239 /*
240 * Merge the wildcard values into the list of values provided
241 * in the query, and create a record containing both.
242 */
243 values = msi_query_merge_record( col_count, iv->vals, record );
244 if( !values )
245 goto err;
246
247 r = msi_arrange_record( iv, &values );
248 if( r != ERROR_SUCCESS )
249 goto err;
250
251 /* rows with NULL primary keys are inserted at the beginning of the table */
252 if( row_has_null_primary_keys( iv, values ) )
253 row = 0;
254
255 r = iv->table->ops->insert_row( iv->table, values, row, iv->bIsTemp );
256
257 err:
258 if( values )
259 msiobj_release( &values->hdr );
260
261 return r;
262 }
263
264
265 static UINT INSERT_close( struct tagMSIVIEW *view )
266 {
267 MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
268 MSIVIEW *sv;
269
270 TRACE("%p\n", iv);
271
272 sv = iv->sv;
273 if( !sv )
274 return ERROR_FUNCTION_FAILED;
275
276 return sv->ops->close( sv );
277 }
278
279 static UINT INSERT_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
280 {
281 MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
282 MSIVIEW *sv;
283
284 TRACE("%p %p %p\n", iv, rows, cols );
285
286 sv = iv->sv;
287 if( !sv )
288 return ERROR_FUNCTION_FAILED;
289
290 return sv->ops->get_dimensions( sv, rows, cols );
291 }
292
293 static UINT INSERT_get_column_info( struct tagMSIVIEW *view,
294 UINT n, LPWSTR *name, UINT *type, BOOL *temporary )
295 {
296 MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
297 MSIVIEW *sv;
298
299 TRACE("%p %d %p %p %p\n", iv, n, name, type, temporary );
300
301 sv = iv->sv;
302 if( !sv )
303 return ERROR_FUNCTION_FAILED;
304
305 return sv->ops->get_column_info( sv, n, name, type, temporary );
306 }
307
308 static UINT INSERT_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
309 {
310 MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
311
312 TRACE("%p %d %p\n", iv, eModifyMode, rec );
313
314 return ERROR_FUNCTION_FAILED;
315 }
316
317 static UINT INSERT_delete( struct tagMSIVIEW *view )
318 {
319 MSIINSERTVIEW *iv = (MSIINSERTVIEW*)view;
320 MSIVIEW *sv;
321
322 TRACE("%p\n", iv );
323
324 sv = iv->sv;
325 if( sv )
326 sv->ops->delete( sv );
327 msiobj_release( &iv->db->hdr );
328 msi_free( iv );
329
330 return ERROR_SUCCESS;
331 }
332
333 static UINT INSERT_find_matching_rows( struct tagMSIVIEW *view, UINT col,
334 UINT val, UINT *row, MSIITERHANDLE *handle )
335 {
336 TRACE("%p, %d, %u, %p\n", view, col, val, *handle);
337
338 return ERROR_FUNCTION_FAILED;
339 }
340
341
342 static const MSIVIEWOPS insert_ops =
343 {
344 INSERT_fetch_int,
345 NULL,
346 NULL,
347 NULL,
348 NULL,
349 NULL,
350 INSERT_execute,
351 INSERT_close,
352 INSERT_get_dimensions,
353 INSERT_get_column_info,
354 INSERT_modify,
355 INSERT_delete,
356 INSERT_find_matching_rows,
357 NULL,
358 NULL,
359 NULL,
360 NULL,
361 NULL,
362 NULL,
363 };
364
365 static UINT count_column_info( const column_info *ci )
366 {
367 UINT n = 0;
368 for ( ; ci; ci = ci->next )
369 n++;
370 return n;
371 }
372
373 UINT INSERT_CreateView( MSIDATABASE *db, MSIVIEW **view, LPCWSTR table,
374 column_info *columns, column_info *values, BOOL temp )
375 {
376 MSIINSERTVIEW *iv = NULL;
377 UINT r;
378 MSIVIEW *tv = NULL, *sv = NULL;
379
380 TRACE("%p\n", iv );
381
382 /* there should be one value for each column */
383 if ( count_column_info( columns ) != count_column_info(values) )
384 return ERROR_BAD_QUERY_SYNTAX;
385
386 r = TABLE_CreateView( db, table, &tv );
387 if( r != ERROR_SUCCESS )
388 return r;
389
390 r = SELECT_CreateView( db, &sv, tv, columns );
391 if( r != ERROR_SUCCESS )
392 {
393 if( tv )
394 tv->ops->delete( tv );
395 return r;
396 }
397
398 iv = msi_alloc_zero( sizeof *iv );
399 if( !iv )
400 return ERROR_FUNCTION_FAILED;
401
402 /* fill the structure */
403 iv->view.ops = &insert_ops;
404 msiobj_addref( &db->hdr );
405 iv->table = tv;
406 iv->db = db;
407 iv->vals = values;
408 iv->bIsTemp = temp;
409 iv->sv = sv;
410 *view = (MSIVIEW*) iv;
411
412 return ERROR_SUCCESS;
413 }