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)sizeof( "SELECT " ) - 1, "SELECT ",
  89                         &at_map->bam_sel_expr,
  90                         (ber_len_t)sizeof( " AS " ) - 1, " AS ",
  91                         &at_map->bam_ad->ad_cname,
  92                         (ber_len_t)sizeof( " FROM " ) - 1, " FROM ",
  93                         &at_map->bam_from_tbls,
  94                         (ber_len_t)sizeof( " WHERE " ) - 1, " WHERE ",
  95                         &oc_map->bom_keytbl,
  96                         '.',
  97                         &oc_map->bom_keycol,
  98                         (ber_len_t)sizeof( "=?" ) - 1, "=?" );
  99
 100         if ( at_map->bam_join_where.bv_val != NULL ) {
 101                 backsql_strfcat( &bb, "lb",
 102                                 (ber_len_t)sizeof( " AND ") - 1, " 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)sizeof( "ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=" ) - 1,
 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)sizeof( " and ldap_entries.oc_map_id=" ) - 1,
 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)sizeof( "ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=" ) - 1,
 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)sizeof( " and ldap_entries.oc_map_id=" ) - 1,
 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 int
 210 backsql_load_schema_map( backsql_info *si, SQLHDBC dbh )
 211 {
 212         SQLHSTMT                oc_sth, at_sth;
 213         RETCODE                 rc;
 214         BACKSQL_ROW_NTS         oc_row, at_row;
 215         unsigned long           oc_id;
 216         backsql_oc_map_rec      *oc_map;
 217         backsql_at_map_rec      *at_map;
 218
 219         Debug( LDAP_DEBUG_TRACE, "==>backsql_load_schema_map()\n", 0, 0, 0 );
 220
 221         /*
 222          * TimesTen : See if the ldap_entries.dn_ru field exists in the schema
 223          */
 224         if ( !BACKSQL_DONTCHECK_LDAPINFO_DN_RU( si ) ) {
 225                 rc = backsql_Prepare( dbh, &oc_sth,
 226                                 backsql_check_dn_ru_query, 0 );
 227                 if ( rc == SQL_SUCCESS ) {
 228                         /* Yes, the field exists */
 229                         si->bsql_flags |= BSQLF_HAS_LDAPINFO_DN_RU;
 230                         Debug( LDAP_DEBUG_TRACE, "ldapinfo.dn_ru field exists "
 231                                 "in the schema\n", 0, 0, 0 );
 232                 } else {
 233                         /* No such field exists */
 234                         si->bsql_flags &= ~BSQLF_HAS_LDAPINFO_DN_RU;
 235                 }
 236
 237                 SQLFreeStmt( oc_sth, SQL_DROP );
 238         }
 239
 240
 241         rc = backsql_Prepare( dbh, &oc_sth, si->oc_query, 0 );
 242         if ( rc != SQL_SUCCESS ) {
 243                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 244                         "error preparing oc_query: '%s'\n",
 245                         si->oc_query, 0, 0 );
 246                 backsql_PrintErrors( si->db_env, dbh, oc_sth, rc );
 247                 return LDAP_OTHER;
 248         }
 249         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): at_query '%s'\n",
 250                         si->at_query, 0, 0 );
 251
 252         rc = backsql_Prepare( dbh, &at_sth, si->at_query, 0 );
 253         if ( rc != SQL_SUCCESS ) {
 254                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 255                         "error preparing at_query: '%s'\n",
 256                         si->at_query, 0, 0 );
 257                 backsql_PrintErrors( si->db_env, dbh, at_sth, rc );
 258                 return LDAP_OTHER;
 259         }
 260
 261         rc = backsql_BindParamID( at_sth, 1, &oc_id );
 262         if ( rc != SQL_SUCCESS ) {
 263                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 264                         "error binding param for at_query: \n", 0, 0, 0 );
 265                 backsql_PrintErrors( si->db_env, dbh, at_sth, rc );
 266                 return LDAP_OTHER;
 267         }
 268
 269         rc = SQLExecute( oc_sth );
 270         if ( rc != SQL_SUCCESS ) {
 271                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 272                         "error executing oc_query: \n", 0, 0, 0 );
 273                 backsql_PrintErrors( si->db_env, dbh, oc_sth, rc );
 274                 return LDAP_OTHER;
 275         }
 276
 277         backsql_BindRowAsStrings( oc_sth, &oc_row );
 278         rc = SQLFetch( oc_sth );
 279         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( oc_sth ) ) {
 280                 int     colnum;
 281
 282                 oc_map = (backsql_oc_map_rec *)ch_calloc( 1,
 283                                 sizeof( backsql_oc_map_rec ) );
 284
 285                 oc_map->bom_id = strtol( oc_row.cols[ 0 ], NULL, 0 );
 286
 287                 oc_map->bom_oc = oc_find( oc_row.cols[ 1 ] );
 288                 if ( oc_map->bom_oc == NULL ) {
 289                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 290                                 "objectClass '%s' is not defined in schema\n",
 291                                 oc_row.cols[ 1 ], 0, 0 );
 292                         return LDAP_OTHER;      /* undefined objectClass ? */
 293                 }
 294
 295                 ber_str2bv( oc_row.cols[ 2 ], 0, 1, &oc_map->bom_keytbl );
 296                 ber_str2bv( oc_row.cols[ 3 ], 0, 1, &oc_map->bom_keycol );
 297                 oc_map->bom_create_proc = ( oc_row.value_len[ 4 ] < 0 ) ? NULL
 298                         : ch_strdup( oc_row.cols[ 4 ] );
 299
 300                 colnum = 5;
 301                 if ( BACKSQL_CREATE_NEEDS_SELECT( si ) ) {
 302                         colnum = 6;
 303                         oc_map->bom_create_keyval = ( oc_row.value_len[ 5 ] < 0 )
 304                                 ? NULL : ch_strdup( oc_row.cols[ 5 ] );
 305                 }
 306                 oc_map->bom_delete_proc = ( oc_row.value_len[ colnum ] < 0 ) ? NULL
 307                         : ch_strdup( oc_row.cols[ colnum ] );
 308                 oc_map->bom_expect_return = strtol( oc_row.cols[ colnum + 1 ],
 309                                 NULL, 0 );
 310
 311                 /*
 312                  * FIXME: first attempt to check for offending
 313                  * instructions in {create|delete}_proc
 314                  */
 315
 316                 oc_map->bom_attrs = NULL;
 317                 if ( avl_insert( &si->oc_by_oc, oc_map, backsql_cmp_oc, avl_dup_error ) == -1 ) {
 318                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 319                                         "duplicate objectClass \"%s\" in objectClass map\n",
 320                                         oc_map->bom_oc->soc_cname.bv_val, 0, 0 );
 321                         return LDAP_OTHER;
 322                 }
 323                 if ( avl_insert( &si->oc_by_id, oc_map, backsql_cmp_oc_id, avl_dup_error ) == -1 ) {
 324                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 325                                         "duplicate objectClass \"%s\" in objectClass by ID map\n",
 326                                         oc_map->bom_oc->soc_cname.bv_val, 0, 0 );
 327                         return LDAP_OTHER;
 328                 }
 329                 oc_id = oc_map->bom_id;
 330                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 331                         "objectClass '%s': keytbl='%s' keycol='%s'\n",
 332                         BACKSQL_OC_NAME( oc_map ),
 333                         oc_map->bom_keytbl.bv_val, oc_map->bom_keycol.bv_val );
 334                 if ( oc_map->bom_create_proc ) {
 335                         Debug( LDAP_DEBUG_TRACE, "create_proc='%s'\n",
 336                                 oc_map->bom_create_proc, 0, 0 );
 337                 }
 338                 if ( oc_map->bom_create_keyval ) {
 339                         Debug( LDAP_DEBUG_TRACE, "create_keyval='%s'\n",
 340                                 oc_map->bom_create_keyval, 0, 0 );
 341                 }
 342                 if ( oc_map->bom_delete_proc ) {
 343                         Debug( LDAP_DEBUG_TRACE, "delete_proc='%s'\n",
 344                                 oc_map->bom_delete_proc, 0, 0 );
 345                 }
 346                 Debug( LDAP_DEBUG_TRACE, "expect_return: "
 347                         "add=%d, del=%d; attributes:\n",
 348                         BACKSQL_IS_ADD( oc_map->bom_expect_return ),
 349                         BACKSQL_IS_DEL( oc_map->bom_expect_return ), 0 );
 350
 351                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 352                         "autoadding 'objectClass' and 'ref' mappings\n",
 353                         0, 0, 0 );
 354                 backsql_add_sysmaps( oc_map );
 355                 rc = SQLExecute( at_sth );
 356                 if ( rc != SQL_SUCCESS ) {
 357                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 358                                 "error executing at_query: \n", 0, 0, 0 );
 359                         backsql_PrintErrors( SQL_NULL_HENV, dbh, at_sth, rc );
 360                         return LDAP_OTHER;
 361                 }
 362
 363                 backsql_BindRowAsStrings( at_sth, &at_row );
 364                 rc = SQLFetch( at_sth );
 365                 for ( ; BACKSQL_SUCCESS(rc); rc = SQLFetch( at_sth ) ) {
 366                         const char      *text = NULL;
 367                         struct berval   bv;
 368                         struct berbuf   bb = BB_NULL;
 369
 370                         Debug( LDAP_DEBUG_TRACE,
 371                                 "attributeType:\n"
 372                                 "\tname='%s'\n"
 373                                 "\tsel_expr='%s'\n"
 374                                 "\tfrom='%s'\n",
 375                                 at_row.cols[ 0 ], at_row.cols[ 1 ],
 376                                 at_row.cols[ 2 ] );
 377                         Debug( LDAP_DEBUG_TRACE,
 378                                 "\tjoin_where='%s'\n"
 379                                 "\tadd_proc='%s'\n"
 380                                 "\tdelete_proc='%s'\n",
 381                                 at_row.cols[ 3 ], at_row.cols[ 4 ],
 382                                 at_row.cols[ 5 ]);
 383                         /* TimesTen */
 384                         Debug( LDAP_DEBUG_TRACE, "\tsel_expr_u='%s'\n",
 385                                         at_row.cols[ 8 ], 0, 0 );
 386                         at_map = (backsql_at_map_rec *)ch_calloc( 1,
 387                                         sizeof( backsql_at_map_rec ) );
 388                         rc = slap_str2ad( at_row.cols[ 0 ],
 389                                         &at_map->bam_ad, &text );
 390                         if ( rc != LDAP_SUCCESS ) {
 391                                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 392                                         "attribute '%s' for objectClass '%s' "
 393                                         "is not defined in schema: %s\n",
 394                                         at_row.cols[ 0 ],
 395                                         BACKSQL_OC_NAME( oc_map ), text );
 396                                 return LDAP_CONSTRAINT_VIOLATION;
 397                         }
 398
 399                         ber_str2bv( at_row.cols[ 1 ], 0, 1, &at_map->bam_sel_expr );
 400                         if ( at_row.value_len[ 8 ] < 0 ) {
 401                                 at_map->bam_sel_expr_u.bv_val = NULL;
 402                                 at_map->bam_sel_expr_u.bv_len = 0;
 403                         } else {
 404                                 ber_str2bv( at_row.cols[ 8 ], 0, 1,
 405                                                 &at_map->bam_sel_expr_u );
 406                         }
 407
 408                         ber_str2bv( at_row.cols[ 2 ], 0, 0, &bv );
 409                         backsql_merge_from_clause( &bb, &bv );
 410                         at_map->bam_from_tbls = bb.bb_val;
 411                         if ( at_row.value_len[ 3 ] < 0 ) {
 412                                 at_map->bam_join_where.bv_val = NULL;
 413                                 at_map->bam_join_where.bv_len = 0;
 414                         } else {
 415                                 ber_str2bv( at_row.cols[ 3 ], 0, 1,
 416                                                 &at_map->bam_join_where );
 417                         }
 418                         at_map->bam_add_proc = NULL;
 419                         if ( at_row.value_len[ 4 ] > 0 ) {
 420                                 at_map->bam_add_proc = ch_strdup( at_row.cols[4] );
 421                         }
 422                         at_map->bam_delete_proc = NULL;
 423                         if ( at_row.value_len[ 5 ] > 0 ) {
 424                                 at_map->bam_delete_proc = ch_strdup( at_row.cols[ 5 ] );
 425                         }
 426                         at_map->bam_param_order = strtol( at_row.cols[ 6 ],
 427                                         NULL, 0 );
 428                         at_map->bam_expect_return = strtol( at_row.cols[ 7 ],
 429                                         NULL, 0 );
 430                         backsql_make_attr_query( oc_map, at_map );
 431                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 432                                 "preconstructed query '%s'\n",
 433                                 at_map->bam_query, 0, 0 );
 434                         at_map->bam_next = NULL;
 435                         if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 436                                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 437                                                 "duplicate attribute \"%s\" "
 438                                                 "in objectClass \"%s\" map\n",
 439                                                 at_map->bam_ad->ad_cname.bv_val,
 440                                                 oc_map->bom_oc->soc_cname.bv_val, 0 );
 441                         }
 442
 443                         if ( si->upper_func.bv_val && at_map->bam_sel_expr_u.bv_val == NULL ) {
 444                                 struct berbuf   bb = BB_NULL;
 445
 446                                 backsql_strfcat( &bb, "bcbc",
 447                                                 &si->upper_func,
 448                                                 '(' /* ) */ ,
 449                                                 &at_map->bam_sel_expr,
 450                                                 /* ( */ ')' );
 451                                 at_map->bam_sel_expr_u = bb.bb_val;
 452                         }
 453                 }
 454                 backsql_FreeRow( &at_row );
 455                 SQLFreeStmt( at_sth, SQL_CLOSE );
 456         }
 457         backsql_FreeRow( &oc_row );
 458         SQLFreeStmt( at_sth, SQL_DROP );
 459         SQLFreeStmt( oc_sth, SQL_DROP );
 460         si->bsql_flags |= BSQLF_SCHEMA_LOADED;
 461         Debug( LDAP_DEBUG_TRACE, "<==backsql_load_schema_map()\n", 0, 0, 0 );
 462         return LDAP_SUCCESS;
 463 }
 464
 465 backsql_oc_map_rec *
 466 backsql_oc2oc( backsql_info *si, ObjectClass *oc )
 467 {
 468         backsql_oc_map_rec      tmp, *res;
 469
 470 #ifdef BACKSQL_TRACE
 471         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc2oc(): "
 472                 "searching for objectclass with name='%s'\n",
 473                 objclass, 0, 0 );
 474 #endif /* BACKSQL_TRACE */
 475
 476         tmp.bom_oc = oc;
 477         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 478 #ifdef BACKSQL_TRACE
 479         if ( res != NULL ) {
 480                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 481                         "found name='%s', id=%d\n",
 482                         BACKSQL_OC_NAME( res ), res->id, 0 );
 483         } else {
 484                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 485                         "not found\n", 0, 0, 0 );
 486         }
 487 #endif /* BACKSQL_TRACE */
 488
 489         return res;
 490 }
 491
 492 backsql_oc_map_rec *
 493 backsql_name2oc( backsql_info *si, struct berval *oc_name )
 494 {
 495         backsql_oc_map_rec      tmp, *res;
 496
 497 #ifdef BACKSQL_TRACE
 498         Debug( LDAP_DEBUG_TRACE, "==>oc_with_name(): "
 499                 "searching for objectclass with name='%s'\n",
 500                 objclass, 0, 0 );
 501 #endif /* BACKSQL_TRACE */
 502
 503         tmp.bom_oc = oc_bvfind( oc_name );
 504         if ( tmp.bom_oc == NULL ) {
 505                 return NULL;
 506         }
 507
 508         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 509 #ifdef BACKSQL_TRACE
 510         if ( res != NULL ) {
 511                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 512                         "found name='%s', id=%d\n",
 513                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 514         } else {
 515                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 516                         "not found\n", 0, 0, 0 );
 517         }
 518 #endif /* BACKSQL_TRACE */
 519
 520         return res;
 521 }
 522
 523 backsql_oc_map_rec *
 524 backsql_id2oc( backsql_info *si, unsigned long id )
 525 {
 526         backsql_oc_map_rec      tmp, *res;
 527
 528 #ifdef BACKSQL_TRACE
 529         Debug( LDAP_DEBUG_TRACE, "==>oc_with_id(): "
 530                 "searching for objectclass with id='%d'\n", id, 0, 0 );
 531 #endif /* BACKSQL_TRACE */
 532
 533         tmp.bom_id = id;
 534         res = (backsql_oc_map_rec *)avl_find( si->oc_by_id, &tmp,
 535                         backsql_cmp_oc_id );
 536
 537 #ifdef BACKSQL_TRACE
 538         if ( res != NULL ) {
 539                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 540                         "found name='%s', id=%d\n",
 541                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 542         } else {
 543                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 544                         "not found\n", 0, 0, 0 );
 545         }
 546 #endif /* BACKSQL_TRACE */
 547
 548         return res;
 549 }
 550
 551 backsql_at_map_rec *
 552 backsql_ad2at( backsql_oc_map_rec* objclass, AttributeDescription *ad )
 553 {
 554         backsql_at_map_rec      tmp, *res;
 555
 556 #ifdef BACKSQL_TRACE
 557         Debug( LDAP_DEBUG_TRACE, "==>backsql_ad2at(): "
 558                 "searching for attribute '%s' for objectclass '%s'\n",
 559                 attr, BACKSQL_OC_NAME( objclass ), 0 );
 560 #endif /* BACKSQL_TRACE */
 561
 562         tmp.bam_ad = ad;
 563         res = (backsql_at_map_rec *)avl_find( objclass->bom_attrs, &tmp,
 564                         backsql_cmp_attr );
 565
 566 #ifdef BACKSQL_TRACE
 567         if ( res != NULL ) {
 568                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 569                         "found name='%s', sel_expr='%s'\n",
 570                         res->bam_ad->ad_cname.bv_val,
 571                         res->bam_sel_expr.bv_val, 0 );
 572         } else {
 573                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 574                         "not found\n", 0, 0, 0 );
 575         }
 576 #endif /* BACKSQL_TRACE */
 577
 578         return res;
 579 }
 580
 581 /* attributeType inheritance */
 582 struct supad2at_t {
 583         backsql_at_map_rec      **ret;
 584         AttributeDescription    *ad;
 585         unsigned                n;
 586 };
 587
 588 #define SUPAD2AT_STOP   (-1)
 589
 590 static int
 591 supad2at_f( void *v_at, void *v_arg )
 592 {
 593         backsql_at_map_rec      *at = (backsql_at_map_rec *)v_at;
 594         struct supad2at_t       *va = (struct supad2at_t *)v_arg;
 595
 596         if ( is_at_subtype( at->bam_ad->ad_type, va->ad->ad_type ) ) {
 597                 backsql_at_map_rec      **ret;
 598
 599                 ret = ch_realloc( va->ret, sizeof( backsql_at_map_rec *) * ( va->n + 2 ) );
 600                 if ( ret == NULL ) {
 601                         ch_free( va->ret );
 602                         return SUPAD2AT_STOP;
 603                 }
 604
 605                 ret[ va->n ] = at;
 606                 va->n++;
 607                 ret[ va->n ] = NULL;
 608                 va->ret = ret;
 609         }
 610
 611         return 0;
 612 }
 613
 614 /*
 615  * stores in *pret a NULL terminated array of pointers
 616  * to backsql_at_map_rec whose attributeType is supad->ad_type
 617  * or derived from it
 618  */
 619 int
 620 backsql_supad2at( backsql_oc_map_rec *objclass, AttributeDescription *supad,
 621                 backsql_at_map_rec ***pret )
 622 {
 623         struct supad2at_t       va;
 624         int                     rc;
 625
 626         assert( objclass );
 627         assert( supad );
 628         assert( pret );
 629
 630         *pret = NULL;
 631
 632         va.ret = NULL;
 633         va.ad = supad;
 634         va.n = 0;
 635
 636         rc = avl_apply( objclass->bom_attrs, supad2at_f, &va,
 637                         SUPAD2AT_STOP, AVL_INORDER );
 638         if ( rc == SUPAD2AT_STOP ) {
 639                 return -1;
 640         }
 641
 642         *pret = va.ret;
 643
 644         return 0;
 645 }
 646
 647 static void
 648 backsql_free_attr( void *v_at )
 649 {
 650         backsql_at_map_rec      *at = v_at;
 651
 652         Debug( LDAP_DEBUG_TRACE, "==>free_attr(): '%s'\n",
 653                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 654         ch_free( at->bam_sel_expr.bv_val );
 655         if ( at->bam_from_tbls.bv_val != NULL ) {
 656                 ch_free( at->bam_from_tbls.bv_val );
 657         }
 658         if ( at->bam_join_where.bv_val != NULL ) {
 659                 ch_free( at->bam_join_where.bv_val );
 660         }
 661         if ( at->bam_add_proc != NULL ) {
 662                 ch_free( at->bam_add_proc );
 663         }
 664         if ( at->bam_delete_proc != NULL ) {
 665                 ch_free( at->bam_delete_proc );
 666         }
 667         if ( at->bam_query ) {
 668                 ch_free( at->bam_query );
 669         }
 670
 671         /* TimesTen */
 672         if ( at->bam_sel_expr_u.bv_val ) {
 673                 ch_free( at->bam_sel_expr_u.bv_val );
 674         }
 675
 676         if ( at->bam_next ) {
 677                 backsql_free_attr( at->bam_next );
 678         }
 679
 680         ch_free( at );
 681
 682         Debug( LDAP_DEBUG_TRACE, "<==free_attr()\n", 0, 0, 0 );
 683 }
 684
 685 static void
 686 backsql_free_oc( void *v_oc )
 687 {
 688         backsql_oc_map_rec      *oc = v_oc;
 689
 690         Debug( LDAP_DEBUG_TRACE, "==>free_oc(): '%s'\n",
 691                         BACKSQL_OC_NAME( oc ), 0, 0 );
 692         avl_free( oc->bom_attrs, backsql_free_attr );
 693         ch_free( oc->bom_keytbl.bv_val );
 694         ch_free( oc->bom_keycol.bv_val );
 695         if ( oc->bom_create_proc != NULL ) {
 696                 ch_free( oc->bom_create_proc );
 697         }
 698         if ( oc->bom_create_keyval != NULL ) {
 699                 ch_free( oc->bom_create_keyval );
 700         }
 701         if ( oc->bom_delete_proc != NULL ) {
 702                 ch_free( oc->bom_delete_proc );
 703         }
 704         ch_free( oc );
 705
 706         Debug( LDAP_DEBUG_TRACE, "<==free_oc()\n", 0, 0, 0 );
 707 }
 708
 709 int
 710 backsql_destroy_schema_map( backsql_info *si )
 711 {
 712         Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n", 0, 0, 0 );
 713         avl_free( si->oc_by_oc, 0 );
 714         avl_free( si->oc_by_id, backsql_free_oc );
 715         Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n", 0, 0, 0 );
 716         return 0;
 717 }
 718
 719 #endif /* SLAPD_SQL */
 720