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