git.sur5r.net Git - openldap/blob - servers/slapd/back-sql/schema-map.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2004 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by Dmitry Kovalev for inclusion
  18  * by OpenLDAP Software.
  19  */
  20
  21 #include "portable.h"
  22
  23 #ifdef SLAPD_SQL
  24
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include "ac/string.h"
  28
  29 #include "slap.h"
  30 #include "lber_pvt.h"
  31 #include "ldap_pvt.h"
  32 #include "proto-sql.h"
  33
  34 #define BACKSQL_DUPLICATE       (-1)
  35
  36 /*
  37  * Uses the pointer to the ObjectClass structure
  38  */
  39 static int
  40 backsql_cmp_oc( const void *v_m1, const void *v_m2 )
  41 {
  42         const backsql_oc_map_rec *m1 = v_m1, *m2 = v_m2;
  43
  44         return SLAP_PTRCMP( m1->bom_oc, m2->bom_oc );
  45 }
  46
  47 static int
  48 backsql_cmp_oc_id( const void *v_m1, const void *v_m2 )
  49 {
  50         const backsql_oc_map_rec *m1 = v_m1, *m2 = v_m2;
  51
  52         return ( m1->bom_id < m2->bom_id ? -1 : ( m1->bom_id > m2->bom_id ? 1 : 0 ) );
  53 }
  54
  55 /*
  56  * Uses the pointer to the AttributeDescription structure
  57  */
  58 static int
  59 backsql_cmp_attr( const void *v_m1, const void *v_m2 )
  60 {
  61         const backsql_at_map_rec *m1 = v_m1, *m2 = v_m2;
  62
  63         return SLAP_PTRCMP( m1->bam_ad, m2->bam_ad );
  64 }
  65
  66 int
  67 backsql_dup_attr( void *v_m1, void *v_m2 )
  68 {
  69         backsql_at_map_rec *m1 = v_m1, *m2 = v_m2;
  70
  71         assert( m1->bam_ad == m2->bam_ad );
  72
  73         for ( ; m1->bam_next ; m1 = m1->bam_next );
  74         m1->bam_next = m2;
  75         m2->bam_next = NULL;
  76
  77         return BACKSQL_DUPLICATE;
  78 }
  79
  80 static int
  81 backsql_make_attr_query(
  82         backsql_oc_map_rec      *oc_map,
  83         backsql_at_map_rec      *at_map )
  84 {
  85         struct berbuf   bb = BB_NULL;
  86
  87         backsql_strfcat( &bb, "lblblblbcbl",
  88                         (ber_len_t)STRLENOF( "SELECT " ), "SELECT ",
  89                         &at_map->bam_sel_expr,
  90                         (ber_len_t)STRLENOF( " AS " ), " AS ",
  91                         &at_map->bam_ad->ad_cname,
  92                         (ber_len_t)STRLENOF( " FROM " ), " FROM ",
  93                         &at_map->bam_from_tbls,
  94                         (ber_len_t)STRLENOF( " WHERE " ), " WHERE ",
  95                         &oc_map->bom_keytbl,
  96                         '.',
  97                         &oc_map->bom_keycol,
  98                         (ber_len_t)STRLENOF( "=?" ), "=?" );
  99
 100         if ( at_map->bam_join_where.bv_val != NULL ) {
 101                 backsql_strfcat( &bb, "lb",
 102                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
 103                                 &at_map->bam_join_where );
 104         }
 105
 106         at_map->bam_query = bb.bb_val.bv_val;
 107
 108         return 0;
 109 }
 110
 111 static int
 112 backsql_add_sysmaps( backsql_oc_map_rec *oc_map )
 113 {
 114         backsql_at_map_rec      *at_map;
 115         char                    s[] = "+9223372036854775807L";
 116         struct berval           sbv;
 117         struct berbuf           bb;
 118
 119         sbv.bv_val = s;
 120         snprintf( s, sizeof( s ), "%ld", oc_map->bom_id );
 121         sbv.bv_len = strlen( s );
 122
 123         /* extra objectClasses */
 124         at_map = (backsql_at_map_rec *)ch_calloc(1,
 125                         sizeof( backsql_at_map_rec ) );
 126         at_map->bam_ad = slap_schema.si_ad_objectClass;
 127         ber_str2bv( "ldap_entry_objclasses.oc_name", 0, 1,
 128                         &at_map->bam_sel_expr );
 129         ber_str2bv( "ldap_entry_objclasses,ldap_entries", 0, 1,
 130                         &at_map->bam_from_tbls );
 131
 132         bb.bb_len = at_map->bam_from_tbls.bv_len + 1;
 133         bb.bb_val = at_map->bam_from_tbls;
 134         backsql_merge_from_clause( &bb, &oc_map->bom_keytbl );
 135         at_map->bam_from_tbls = bb.bb_val;
 136
 137         bb.bb_val.bv_val = NULL;
 138         bb.bb_val.bv_len = 0;
 139         bb.bb_len = 0;
 140         backsql_strfcat( &bb, "lbcblb",
 141                         (ber_len_t)STRLENOF( "ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=" ),
 142                                 "ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=",
 143                         &oc_map->bom_keytbl,
 144                         '.',
 145                         &oc_map->bom_keycol,
 146                         (ber_len_t)STRLENOF( " and ldap_entries.oc_map_id=" ),
 147                                 " and ldap_entries.oc_map_id=",
 148                         &sbv );
 149
 150         at_map->bam_oc = oc_map->bom_oc;
 151         at_map->bam_join_where = bb.bb_val;
 152         at_map->bam_add_proc = NULL;
 153         at_map->bam_delete_proc = NULL;
 154         at_map->bam_param_order = 0;
 155         at_map->bam_expect_return = 0;
 156         at_map->bam_next = NULL;
 157
 158         backsql_make_attr_query( oc_map, at_map );
 159         if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 160                 Debug( LDAP_DEBUG_TRACE, "backsql_add_sysmaps(): "
 161                                 "duplicate attribute \"%s\" in objectClass \"%s\" map\n",
 162                                 at_map->bam_ad->ad_cname.bv_val,
 163                                 oc_map->bom_oc->soc_cname.bv_val, 0 );
 164         }
 165
 166         /* referral attribute */
 167         at_map = (backsql_at_map_rec *)ch_calloc( 1,
 168                         sizeof( backsql_at_map_rec ) );
 169         at_map->bam_ad = slap_schema.si_ad_ref;
 170         ber_str2bv( "ldap_referrals.url", 0, 1, &at_map->bam_sel_expr );
 171         ber_str2bv( "ldap_referrals,ldap_entries", 0, 1, &at_map->bam_from_tbls );
 172
 173         bb.bb_len = at_map->bam_from_tbls.bv_len + 1;
 174         bb.bb_val = at_map->bam_from_tbls;
 175         backsql_merge_from_clause( &bb, &oc_map->bom_keytbl );
 176         at_map->bam_from_tbls = bb.bb_val;
 177
 178         bb.bb_val.bv_val = NULL;
 179         bb.bb_val.bv_len = 0;
 180         bb.bb_len = 0;
 181         backsql_strfcat( &bb, "lbcblb",
 182                         (ber_len_t)STRLENOF( "ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=" ),
 183                                 "ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=",
 184                         &oc_map->bom_keytbl,
 185                         '.',
 186                         &oc_map->bom_keycol,
 187                         (ber_len_t)STRLENOF( " and ldap_entries.oc_map_id=" ),
 188                                 " and ldap_entries.oc_map_id=",
 189                         &sbv );
 190
 191         at_map->bam_oc = NULL;
 192         at_map->bam_join_where = bb.bb_val;
 193         at_map->bam_add_proc = NULL;
 194         at_map->bam_delete_proc = NULL;
 195         at_map->bam_param_order = 0;
 196         at_map->bam_expect_return = 0;
 197         at_map->bam_next = NULL;
 198
 199         backsql_make_attr_query( oc_map, at_map );
 200         if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 201                 Debug( LDAP_DEBUG_TRACE, "backsql_add_sysmaps(): "
 202                                 "duplicate attribute \"%s\" in objectClass \"%s\" map\n",
 203                                 at_map->bam_ad->ad_cname.bv_val,
 204                                 oc_map->bom_oc->soc_cname.bv_val, 0 );
 205         }
 206
 207         return 1;
 208 }
 209
 210 struct backsql_attr_schema_info {
 211         backsql_info    *bas_si;
 212         SQLHDBC         bas_dbh;
 213         SQLHSTMT        bas_sth;
 214         unsigned long   *bas_oc_id;
 215         int             bas_rc;
 216 };
 217
 218 static int
 219 backsql_oc_get_attr_mapping( void *v_oc, void *v_bas )
 220 {
 221         RETCODE                         rc;
 222         BACKSQL_ROW_NTS                 at_row;
 223         backsql_oc_map_rec              *oc_map = (backsql_oc_map_rec *)v_oc;
 224         backsql_at_map_rec              *at_map;
 225         struct backsql_attr_schema_info *bas = (struct backsql_attr_schema_info *)v_bas;
 226
 227         /* bas->bas_oc_id has been bound to bas->bas_sth */
 228         *bas->bas_oc_id = oc_map->bom_id;
 229
 230         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): "
 231                 "executing at_query\n"
 232                 "    \"%s\"\n"
 233                 "    for objectClass \"%s\"\n"
 234                 "    with param oc_id=\"%lu\"\n",
 235                 bas->bas_si->at_query,
 236                 BACKSQL_OC_NAME( oc_map ),
 237                 *bas->bas_oc_id );
 238
 239         rc = SQLExecute( bas->bas_sth );
 240         if ( rc != SQL_SUCCESS ) {
 241                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): "
 242                         "error executing at_query\n"
 243                         "    \"%s\"\n"
 244                         "    for objectClass \"%s\"\n"
 245                         "    with param oc_id=\"%lu\"\n",
 246                         bas->bas_si->at_query,
 247                         BACKSQL_OC_NAME( oc_map ),
 248                         *bas->bas_oc_id );
 249                 backsql_PrintErrors( SQL_NULL_HENV, bas->bas_dbh, bas->bas_sth, rc );
 250                 bas->bas_rc = LDAP_OTHER;
 251                 return BACKSQL_AVL_STOP;
 252         }
 253
 254         backsql_BindRowAsStrings( bas->bas_sth, &at_row );
 255         for ( ; rc = SQLFetch( bas->bas_sth ), BACKSQL_SUCCESS( rc ); ) {
 256                 const char      *text = NULL;
 257                 struct berval   bv;
 258                 struct berbuf   bb = BB_NULL;
 259
 260                 Debug( LDAP_DEBUG_TRACE,
 261                         "attributeType:\n"
 262                         "\tname=\"%s\"\n"
 263                         "\tsel_expr=\"%s\"\n"
 264                         "\tfrom=\"%s\"\n",
 265                         at_row.cols[ 0 ], at_row.cols[ 1 ],
 266                         at_row.cols[ 2 ] );
 267                 Debug( LDAP_DEBUG_TRACE,
 268                         "\tjoin_where=\"%s\"\n"
 269                         "\tadd_proc=\"%s\"\n"
 270                         "\tdelete_proc=\"%s\"\n",
 271                         at_row.cols[ 3 ], at_row.cols[ 4 ],
 272                         at_row.cols[ 5 ]);
 273                 /* TimesTen */
 274                 Debug( LDAP_DEBUG_TRACE, "\tsel_expr_u=\"%s\"\n",
 275                                 at_row.cols[ 8 ], 0, 0 );
 276                 at_map = (backsql_at_map_rec *)ch_calloc( 1,
 277                                 sizeof( backsql_at_map_rec ) );
 278                 rc = slap_str2ad( at_row.cols[ 0 ],
 279                                 &at_map->bam_ad, &text );
 280                 if ( rc != LDAP_SUCCESS ) {
 281                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): "
 282                                 "attribute \"%s\" for objectClass \"%s\" "
 283                                 "is not defined in schema: %s\n",
 284                                 at_row.cols[ 0 ],
 285                                 BACKSQL_OC_NAME( oc_map ), text );
 286                         bas->bas_rc = LDAP_CONSTRAINT_VIOLATION;
 287                         return BACKSQL_AVL_STOP;
 288                 }
 289
 290                 ber_str2bv( at_row.cols[ 1 ], 0, 1, &at_map->bam_sel_expr );
 291                 if ( at_row.value_len[ 8 ] < 0 ) {
 292                         at_map->bam_sel_expr_u.bv_val = NULL;
 293                         at_map->bam_sel_expr_u.bv_len = 0;
 294
 295                 } else {
 296                         ber_str2bv( at_row.cols[ 8 ], 0, 1,
 297                                         &at_map->bam_sel_expr_u );
 298                 }
 299
 300                 ber_str2bv( at_row.cols[ 2 ], 0, 0, &bv );
 301                 backsql_merge_from_clause( &bb, &bv );
 302                 at_map->bam_from_tbls = bb.bb_val;
 303                 if ( at_row.value_len[ 3 ] < 0 ) {
 304                         at_map->bam_join_where.bv_val = NULL;
 305                         at_map->bam_join_where.bv_len = 0;
 306
 307                 } else {
 308                         ber_str2bv( at_row.cols[ 3 ], 0, 1,
 309                                         &at_map->bam_join_where );
 310                 }
 311                 at_map->bam_add_proc = NULL;
 312                 if ( at_row.value_len[ 4 ] > 0 ) {
 313                         at_map->bam_add_proc = ch_strdup( at_row.cols[4] );
 314                 }
 315                 at_map->bam_delete_proc = NULL;
 316                 if ( at_row.value_len[ 5 ] > 0 ) {
 317                         at_map->bam_delete_proc = ch_strdup( at_row.cols[ 5 ] );
 318                 }
 319                 at_map->bam_param_order = strtol( at_row.cols[ 6 ],
 320                                 NULL, 0 );
 321                 at_map->bam_expect_return = strtol( at_row.cols[ 7 ],
 322                                 NULL, 0 );
 323                 backsql_make_attr_query( oc_map, at_map );
 324                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): "
 325                         "preconstructed query \"%s\"\n",
 326                         at_map->bam_query, 0, 0 );
 327                 at_map->bam_next = NULL;
 328                 if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 329                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): "
 330                                         "duplicate attribute \"%s\" "
 331                                         "in objectClass \"%s\" map\n",
 332                                         at_map->bam_ad->ad_cname.bv_val,
 333                                         oc_map->bom_oc->soc_cname.bv_val, 0 );
 334                 }
 335
 336                 if ( bas->bas_si->upper_func.bv_val && at_map->bam_sel_expr_u.bv_val == NULL ) {
 337                         struct berbuf   bb = BB_NULL;
 338
 339                         backsql_strfcat( &bb, "bcbc",
 340                                         &bas->bas_si->upper_func,
 341                                         '(' /* ) */ ,
 342                                         &at_map->bam_sel_expr,
 343                                         /* ( */ ')' );
 344                         at_map->bam_sel_expr_u = bb.bb_val;
 345                 }
 346         }
 347         backsql_FreeRow( &at_row );
 348         SQLFreeStmt( bas->bas_sth, SQL_CLOSE );
 349
 350         return BACKSQL_AVL_CONTINUE;
 351 }
 352
 353
 354 int
 355 backsql_load_schema_map( backsql_info *si, SQLHDBC dbh )
 356 {
 357         SQLHSTMT                        sth;
 358         RETCODE                         rc;
 359         BACKSQL_ROW_NTS                 oc_row;
 360         unsigned long                   oc_id;
 361         backsql_oc_map_rec              *oc_map;
 362         struct backsql_attr_schema_info bas;
 363
 364         Debug( LDAP_DEBUG_TRACE, "==>backsql_load_schema_map()\n", 0, 0, 0 );
 365
 366         /*
 367          * TimesTen : See if the ldap_entries.dn_ru field exists in the schema
 368          */
 369         if ( !BACKSQL_DONTCHECK_LDAPINFO_DN_RU( si ) ) {
 370                 rc = backsql_Prepare( dbh, &sth,
 371                                 backsql_check_dn_ru_query, 0 );
 372                 if ( rc == SQL_SUCCESS ) {
 373                         /* Yes, the field exists */
 374                         si->bsql_flags |= BSQLF_HAS_LDAPINFO_DN_RU;
 375                         Debug( LDAP_DEBUG_TRACE, "ldapinfo.dn_ru field exists "
 376                                 "in the schema\n", 0, 0, 0 );
 377                 } else {
 378                         /* No such field exists */
 379                         si->bsql_flags &= ~BSQLF_HAS_LDAPINFO_DN_RU;
 380                 }
 381
 382                 SQLFreeStmt( sth, SQL_DROP );
 383         }
 384
 385         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): oc_query \"%s\"\n",
 386                         si->oc_query, 0, 0 );
 387
 388         rc = backsql_Prepare( dbh, &sth, si->oc_query, 0 );
 389         if ( rc != SQL_SUCCESS ) {
 390                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 391                         "error preparing oc_query: \"%s\"\n",
 392                         si->oc_query, 0, 0 );
 393                 backsql_PrintErrors( si->db_env, dbh, sth, rc );
 394                 return LDAP_OTHER;
 395         }
 396
 397         rc = SQLExecute( sth );
 398         if ( rc != SQL_SUCCESS ) {
 399                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 400                         "error executing oc_query: \n", 0, 0, 0 );
 401                 backsql_PrintErrors( si->db_env, dbh, sth, rc );
 402                 return LDAP_OTHER;
 403         }
 404
 405         backsql_BindRowAsStrings( sth, &oc_row );
 406         rc = SQLFetch( sth );
 407         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ) ) {
 408                 int     colnum;
 409
 410                 oc_map = (backsql_oc_map_rec *)ch_calloc( 1,
 411                                 sizeof( backsql_oc_map_rec ) );
 412
 413                 oc_map->bom_id = strtol( oc_row.cols[ 0 ], NULL, 0 );
 414
 415                 oc_map->bom_oc = oc_find( oc_row.cols[ 1 ] );
 416                 if ( oc_map->bom_oc == NULL ) {
 417                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 418                                 "objectClass \"%s\" is not defined in schema\n",
 419                                 oc_row.cols[ 1 ], 0, 0 );
 420                         return LDAP_OTHER;      /* undefined objectClass ? */
 421                 }
 422
 423                 ber_str2bv( oc_row.cols[ 2 ], 0, 1, &oc_map->bom_keytbl );
 424                 ber_str2bv( oc_row.cols[ 3 ], 0, 1, &oc_map->bom_keycol );
 425                 oc_map->bom_create_proc = ( oc_row.value_len[ 4 ] < 0 ) ? NULL
 426                         : ch_strdup( oc_row.cols[ 4 ] );
 427
 428                 colnum = 5;
 429                 if ( BACKSQL_CREATE_NEEDS_SELECT( si ) ) {
 430                         colnum = 6;
 431                         oc_map->bom_create_keyval = ( oc_row.value_len[ 5 ] < 0 )
 432                                 ? NULL : ch_strdup( oc_row.cols[ 5 ] );
 433                 }
 434                 oc_map->bom_delete_proc = ( oc_row.value_len[ colnum ] < 0 ) ? NULL
 435                         : ch_strdup( oc_row.cols[ colnum ] );
 436                 oc_map->bom_expect_return = strtol( oc_row.cols[ colnum + 1 ],
 437                                 NULL, 0 );
 438
 439                 /*
 440                  * FIXME: first attempt to check for offending
 441                  * instructions in {create|delete}_proc
 442                  */
 443
 444                 oc_map->bom_attrs = NULL;
 445                 if ( avl_insert( &si->oc_by_oc, oc_map, backsql_cmp_oc, avl_dup_error ) == -1 ) {
 446                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 447                                         "duplicate objectClass \"%s\" in objectClass map\n",
 448                                         oc_map->bom_oc->soc_cname.bv_val, 0, 0 );
 449                         return LDAP_OTHER;
 450                 }
 451                 if ( avl_insert( &si->oc_by_id, oc_map, backsql_cmp_oc_id, avl_dup_error ) == -1 ) {
 452                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 453                                         "duplicate objectClass \"%s\" in objectClass by ID map\n",
 454                                         oc_map->bom_oc->soc_cname.bv_val, 0, 0 );
 455                         return LDAP_OTHER;
 456                 }
 457                 oc_id = oc_map->bom_id;
 458                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 459                         "objectClass \"%s\": keytbl=\"%s\" keycol=\"%s\"\n",
 460                         BACKSQL_OC_NAME( oc_map ),
 461                         oc_map->bom_keytbl.bv_val, oc_map->bom_keycol.bv_val );
 462                 if ( oc_map->bom_create_proc ) {
 463                         Debug( LDAP_DEBUG_TRACE, "create_proc=\"%s\"\n",
 464                                 oc_map->bom_create_proc, 0, 0 );
 465                 }
 466                 if ( oc_map->bom_create_keyval ) {
 467                         Debug( LDAP_DEBUG_TRACE, "create_keyval=\"%s\"\n",
 468                                 oc_map->bom_create_keyval, 0, 0 );
 469                 }
 470                 if ( oc_map->bom_delete_proc ) {
 471                         Debug( LDAP_DEBUG_TRACE, "delete_proc=\"%s\"\n",
 472                                 oc_map->bom_delete_proc, 0, 0 );
 473                 }
 474                 Debug( LDAP_DEBUG_TRACE, "expect_return: "
 475                         "add=%d, del=%d; attributes:\n",
 476                         BACKSQL_IS_ADD( oc_map->bom_expect_return ),
 477                         BACKSQL_IS_DEL( oc_map->bom_expect_return ), 0 );
 478
 479                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 480                         "autoadding 'objectClass' and 'ref' mappings\n",
 481                         0, 0, 0 );
 482
 483                 backsql_add_sysmaps( oc_map );
 484         }
 485
 486         backsql_FreeRow( &oc_row );
 487         SQLFreeStmt( sth, SQL_DROP );
 488
 489         /* prepare for attribute fetching */
 490         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): at_query \"%s\"\n",
 491                         si->at_query, 0, 0 );
 492
 493         rc = backsql_Prepare( dbh, &sth, si->at_query, 0 );
 494         if ( rc != SQL_SUCCESS ) {
 495                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 496                         "error preparing at_query: \"%s\"\n",
 497                         si->at_query, 0, 0 );
 498                 backsql_PrintErrors( si->db_env, dbh, sth, rc );
 499                 return LDAP_OTHER;
 500         }
 501
 502         rc = backsql_BindParamID( sth, 1, &oc_id );
 503         if ( rc != SQL_SUCCESS ) {
 504                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 505                         "error binding param \"oc_id\" for at_query\n", 0, 0, 0 );
 506                 backsql_PrintErrors( si->db_env, dbh, sth, rc );
 507                 return LDAP_OTHER;
 508         }
 509
 510         bas.bas_si = si;
 511         bas.bas_dbh = dbh;
 512         bas.bas_sth = sth;
 513         bas.bas_oc_id = &oc_id;
 514         bas.bas_rc = LDAP_SUCCESS;
 515
 516         (void)avl_apply( si->oc_by_oc, backsql_oc_get_attr_mapping,
 517                         &bas, BACKSQL_AVL_STOP, AVL_INORDER );
 518
 519         SQLFreeStmt( sth, SQL_DROP );
 520
 521         si->bsql_flags |= BSQLF_SCHEMA_LOADED;
 522
 523         Debug( LDAP_DEBUG_TRACE, "<==backsql_load_schema_map()\n", 0, 0, 0 );
 524
 525         return bas.bas_rc;
 526 }
 527
 528 backsql_oc_map_rec *
 529 backsql_oc2oc( backsql_info *si, ObjectClass *oc )
 530 {
 531         backsql_oc_map_rec      tmp, *res;
 532
 533 #ifdef BACKSQL_TRACE
 534         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc2oc(): "
 535                 "searching for objectclass with name=\"%s\"\n",
 536                 oc->soc_cname.bv_val, 0, 0 );
 537 #endif /* BACKSQL_TRACE */
 538
 539         tmp.bom_oc = oc;
 540         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 541 #ifdef BACKSQL_TRACE
 542         if ( res != NULL ) {
 543                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 544                         "found name=\"%s\", id=%d\n",
 545                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 546         } else {
 547                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 548                         "not found\n", 0, 0, 0 );
 549         }
 550 #endif /* BACKSQL_TRACE */
 551
 552         return res;
 553 }
 554
 555 backsql_oc_map_rec *
 556 backsql_name2oc( backsql_info *si, struct berval *oc_name )
 557 {
 558         backsql_oc_map_rec      tmp, *res;
 559
 560 #ifdef BACKSQL_TRACE
 561         Debug( LDAP_DEBUG_TRACE, "==>oc_with_name(): "
 562                 "searching for objectclass with name=\"%s\"\n",
 563                 oc_name->bv_val, 0, 0 );
 564 #endif /* BACKSQL_TRACE */
 565
 566         tmp.bom_oc = oc_bvfind( oc_name );
 567         if ( tmp.bom_oc == NULL ) {
 568                 return NULL;
 569         }
 570
 571         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 572 #ifdef BACKSQL_TRACE
 573         if ( res != NULL ) {
 574                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 575                         "found name=\"%s\", id=%d\n",
 576                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 577         } else {
 578                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 579                         "not found\n", 0, 0, 0 );
 580         }
 581 #endif /* BACKSQL_TRACE */
 582
 583         return res;
 584 }
 585
 586 backsql_oc_map_rec *
 587 backsql_id2oc( backsql_info *si, unsigned long id )
 588 {
 589         backsql_oc_map_rec      tmp, *res;
 590
 591 #ifdef BACKSQL_TRACE
 592         Debug( LDAP_DEBUG_TRACE, "==>oc_with_id(): "
 593                 "searching for objectclass with id='%d'\n", id, 0, 0 );
 594 #endif /* BACKSQL_TRACE */
 595
 596         tmp.bom_id = id;
 597         res = (backsql_oc_map_rec *)avl_find( si->oc_by_id, &tmp,
 598                         backsql_cmp_oc_id );
 599
 600 #ifdef BACKSQL_TRACE
 601         if ( res != NULL ) {
 602                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 603                         "found name=\"%s\", id=%d\n",
 604                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 605         } else {
 606                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 607                         "not found\n", 0, 0, 0 );
 608         }
 609 #endif /* BACKSQL_TRACE */
 610
 611         return res;
 612 }
 613
 614 backsql_at_map_rec *
 615 backsql_ad2at( backsql_oc_map_rec* objclass, AttributeDescription *ad )
 616 {
 617         backsql_at_map_rec      tmp, *res;
 618
 619 #ifdef BACKSQL_TRACE
 620         Debug( LDAP_DEBUG_TRACE, "==>backsql_ad2at(): "
 621                 "searching for attribute \"%s\" for objectclass \"%s\"\n",
 622                 ad->ad_cname.bv_val, BACKSQL_OC_NAME( objclass ), 0 );
 623 #endif /* BACKSQL_TRACE */
 624
 625         tmp.bam_ad = ad;
 626         res = (backsql_at_map_rec *)avl_find( objclass->bom_attrs, &tmp,
 627                         backsql_cmp_attr );
 628
 629 #ifdef BACKSQL_TRACE
 630         if ( res != NULL ) {
 631                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 632                         "found name=\"%s\", sel_expr=\"%s\"\n",
 633                         res->bam_ad->ad_cname.bv_val,
 634                         res->bam_sel_expr.bv_val, 0 );
 635         } else {
 636                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 637                         "not found\n", 0, 0, 0 );
 638         }
 639 #endif /* BACKSQL_TRACE */
 640
 641         return res;
 642 }
 643
 644 /* attributeType inheritance */
 645 struct supad2at_t {
 646         backsql_at_map_rec      **ret;
 647         AttributeDescription    *ad;
 648         unsigned                n;
 649 };
 650
 651 #define SUPAD2AT_STOP   (-1)
 652
 653 static int
 654 supad2at_f( void *v_at, void *v_arg )
 655 {
 656         backsql_at_map_rec      *at = (backsql_at_map_rec *)v_at;
 657         struct supad2at_t       *va = (struct supad2at_t *)v_arg;
 658
 659         if ( is_at_subtype( at->bam_ad->ad_type, va->ad->ad_type ) ) {
 660                 backsql_at_map_rec      **ret;
 661                 unsigned                i;
 662
 663                 /* if already listed, holler! (should never happen) */
 664                 if ( va->ret ) {
 665                         for ( i = 0; i < va->n; i++ ) {
 666                                 if ( va->ret[ i ]->bam_ad == at->bam_ad ) {
 667                                         break;
 668                                 }
 669                         }
 670
 671                         if ( i < va->n ) {
 672                                 return 0;
 673                         }
 674                 }
 675
 676                 ret = ch_realloc( va->ret,
 677                                 sizeof( backsql_at_map_rec *) * ( va->n + 2 ) );
 678                 if ( ret == NULL ) {
 679                         ch_free( va->ret );
 680                         return SUPAD2AT_STOP;
 681                 }
 682
 683                 ret[ va->n ] = at;
 684                 va->n++;
 685                 ret[ va->n ] = NULL;
 686                 va->ret = ret;
 687         }
 688
 689         return 0;
 690 }
 691
 692 /*
 693  * stores in *pret a NULL terminated array of pointers
 694  * to backsql_at_map_rec whose attributeType is supad->ad_type
 695  * or derived from it
 696  */
 697 int
 698 backsql_supad2at( backsql_oc_map_rec *objclass, AttributeDescription *supad,
 699                 backsql_at_map_rec ***pret )
 700 {
 701         struct supad2at_t       va;
 702         int                     rc;
 703
 704         assert( objclass );
 705         assert( supad );
 706         assert( pret );
 707
 708         *pret = NULL;
 709
 710         va.ret = NULL;
 711         va.ad = supad;
 712         va.n = 0;
 713
 714         rc = avl_apply( objclass->bom_attrs, supad2at_f, &va,
 715                         SUPAD2AT_STOP, AVL_INORDER );
 716         if ( rc == SUPAD2AT_STOP ) {
 717                 return -1;
 718         }
 719
 720         *pret = va.ret;
 721
 722         return 0;
 723 }
 724
 725 static void
 726 backsql_free_attr( void *v_at )
 727 {
 728         backsql_at_map_rec      *at = v_at;
 729
 730         Debug( LDAP_DEBUG_TRACE, "==>free_attr(): \"%s\"\n",
 731                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 732         ch_free( at->bam_sel_expr.bv_val );
 733         if ( at->bam_from_tbls.bv_val != NULL ) {
 734                 ch_free( at->bam_from_tbls.bv_val );
 735         }
 736         if ( at->bam_join_where.bv_val != NULL ) {
 737                 ch_free( at->bam_join_where.bv_val );
 738         }
 739         if ( at->bam_add_proc != NULL ) {
 740                 ch_free( at->bam_add_proc );
 741         }
 742         if ( at->bam_delete_proc != NULL ) {
 743                 ch_free( at->bam_delete_proc );
 744         }
 745         if ( at->bam_query ) {
 746                 ch_free( at->bam_query );
 747         }
 748
 749         /* TimesTen */
 750         if ( at->bam_sel_expr_u.bv_val ) {
 751                 ch_free( at->bam_sel_expr_u.bv_val );
 752         }
 753
 754         if ( at->bam_next ) {
 755                 backsql_free_attr( at->bam_next );
 756         }
 757
 758         ch_free( at );
 759
 760         Debug( LDAP_DEBUG_TRACE, "<==free_attr()\n", 0, 0, 0 );
 761 }
 762
 763 static void
 764 backsql_free_oc( void *v_oc )
 765 {
 766         backsql_oc_map_rec      *oc = v_oc;
 767
 768         Debug( LDAP_DEBUG_TRACE, "==>free_oc(): \"%s\"\n",
 769                         BACKSQL_OC_NAME( oc ), 0, 0 );
 770         avl_free( oc->bom_attrs, backsql_free_attr );
 771         ch_free( oc->bom_keytbl.bv_val );
 772         ch_free( oc->bom_keycol.bv_val );
 773         if ( oc->bom_create_proc != NULL ) {
 774                 ch_free( oc->bom_create_proc );
 775         }
 776         if ( oc->bom_create_keyval != NULL ) {
 777                 ch_free( oc->bom_create_keyval );
 778         }
 779         if ( oc->bom_delete_proc != NULL ) {
 780                 ch_free( oc->bom_delete_proc );
 781         }
 782         ch_free( oc );
 783
 784         Debug( LDAP_DEBUG_TRACE, "<==free_oc()\n", 0, 0, 0 );
 785 }
 786
 787 int
 788 backsql_destroy_schema_map( backsql_info *si )
 789 {
 790         Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n", 0, 0, 0 );
 791         avl_free( si->oc_by_oc, 0 );
 792         avl_free( si->oc_by_id, backsql_free_oc );
 793         Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n", 0, 0, 0 );
 794         return 0;
 795 }
 796
 797 #endif /* SLAPD_SQL */
 798