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 #include "slap.h"
  29 #include "lber_pvt.h"
  30 #include "ldap_pvt.h"
  31 #include "back-sql.h"
  32 #include "sql-wrap.h"
  33 #include "schema-map.h"
  34 #include "util.h"
  35
  36 #define BACKSQL_DUPLICATE       (-1)
  37
  38 /*
  39  * Uses the pointer to the ObjectClass structure
  40  */
  41 static int
  42 backsql_cmp_oc( const void *v_m1, const void *v_m2 )
  43 {
  44         const backsql_oc_map_rec *m1 = v_m1, *m2 = v_m2;
  45
  46         return SLAP_PTRCMP( m1->bom_oc, m2->bom_oc );
  47 }
  48
  49 static int
  50 backsql_cmp_oc_id( const void *v_m1, const void *v_m2 )
  51 {
  52         const backsql_oc_map_rec *m1 = v_m1, *m2 = v_m2;
  53
  54         return ( m1->bom_id < m2->bom_id ? -1 : ( m1->bom_id > m2->bom_id ? 1 : 0 ) );
  55 }
  56
  57 /*
  58  * Uses the pointer to the AttributeDescription structure
  59  */
  60 static int
  61 backsql_cmp_attr( const void *v_m1, const void *v_m2 )
  62 {
  63         const backsql_at_map_rec *m1 = v_m1, *m2 = v_m2;
  64
  65         return SLAP_PTRCMP( m1->bam_ad, m2->bam_ad );
  66 }
  67
  68 int
  69 backsql_dup_attr( void *v_m1, void *v_m2 )
  70 {
  71         backsql_at_map_rec *m1 = v_m1, *m2 = v_m2;
  72
  73         assert( m1->bam_ad == m2->bam_ad );
  74
  75         for ( ; m1->bam_next ; m1 = m1->bam_next );
  76         m1->bam_next = m2;
  77         m2->bam_next = NULL;
  78
  79         return BACKSQL_DUPLICATE;
  80 }
  81
  82 static int
  83 backsql_make_attr_query(
  84         backsql_oc_map_rec      *oc_map,
  85         backsql_at_map_rec      *at_map )
  86 {
  87         struct berbuf   bb = BB_NULL;
  88
  89         backsql_strfcat( &bb, "lblblblbcbl",
  90                         (ber_len_t)sizeof( "SELECT " ) - 1, "SELECT ",
  91                         &at_map->bam_sel_expr,
  92                         (ber_len_t)sizeof( " AS " ) - 1, " AS ",
  93                         &at_map->bam_ad->ad_cname,
  94                         (ber_len_t)sizeof( " FROM " ) - 1, " FROM ",
  95                         &at_map->bam_from_tbls,
  96                         (ber_len_t)sizeof( " WHERE " ) - 1, " WHERE ",
  97                         &oc_map->bom_keytbl,
  98                         '.',
  99                         &oc_map->bom_keycol,
 100                         (ber_len_t)sizeof( "=?" ) - 1, "=?" );
 101
 102         if ( at_map->bam_join_where.bv_val != NULL ) {
 103                 backsql_strfcat( &bb, "lb",
 104                                 (ber_len_t)sizeof( " AND ") - 1, " AND ",
 105                                 &at_map->bam_join_where );
 106         }
 107
 108         at_map->bam_query = bb.bb_val.bv_val;
 109
 110         return 0;
 111 }
 112
 113 static int
 114 backsql_add_sysmaps( backsql_oc_map_rec *oc_map )
 115 {
 116         backsql_at_map_rec      *at_map;
 117         char                    s[] = "+9223372036854775807L";
 118         ber_len_t               slen;
 119         struct berbuf           bb;
 120
 121
 122         snprintf( s, sizeof( s ), "%ld", oc_map->bom_id );
 123         slen = strlen( s );
 124
 125         at_map = (backsql_at_map_rec *)ch_calloc(1,
 126                         sizeof( backsql_at_map_rec ) );
 127         at_map->bam_ad = slap_schema.si_ad_objectClass;
 128         ber_str2bv( "ldap_entry_objclasses.oc_name", 0, 1,
 129                         &at_map->bam_sel_expr );
 130         ber_str2bv( "ldap_entry_objclasses,ldap_entries", 0, 1,
 131                         &at_map->bam_from_tbls );
 132
 133         bb.bb_len = at_map->bam_from_tbls.bv_len + 1;
 134         bb.bb_val = at_map->bam_from_tbls;
 135         backsql_merge_from_clause( &bb, &oc_map->bom_keytbl );
 136         at_map->bam_from_tbls = bb.bb_val;
 137
 138         bb.bb_val.bv_val = NULL;
 139         bb.bb_val.bv_len = 0;
 140         bb.bb_len = 0;
 141         backsql_strfcat( &bb, "lbcbll",
 142                         (ber_len_t)sizeof( "ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=" ) - 1,
 143                                 "ldap_entries.id=ldap_entry_objclasses.entry_id and ldap_entries.keyval=",
 144                         &oc_map->bom_keytbl,
 145                         '.',
 146                         &oc_map->bom_keycol,
 147                         (ber_len_t)sizeof( " and ldap_entries.oc_map_id=" ) - 1,
 148                                 " and ldap_entries.oc_map_id=",
 149                         slen, s );
 150
 151         at_map->bam_oc = oc_map->bom_oc;
 152         at_map->bam_join_where = bb.bb_val;
 153         at_map->bam_add_proc = NULL;
 154         at_map->bam_delete_proc = NULL;
 155         at_map->bam_param_order = 0;
 156         at_map->bam_expect_return = 0;
 157         at_map->bam_next = NULL;
 158
 159         backsql_make_attr_query( oc_map, at_map );
 160         if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 161                 Debug( LDAP_DEBUG_TRACE, "backsql_add_sysmaps(): "
 162                                 "duplicate attribute \"%s\" in objectClass \"%s\" map\n",
 163                                 at_map->bam_ad->ad_cname.bv_val,
 164                                 oc_map->bom_oc->soc_cname.bv_val, 0 );
 165         }
 166
 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_val.bv_val = NULL;
 174         bb.bb_val.bv_len = 0;
 175         bb.bb_len = at_map->bam_from_tbls.bv_len + 1;
 176         backsql_merge_from_clause( &bb, &oc_map->bom_keytbl );
 177         at_map->bam_from_tbls = bb.bb_val;
 178
 179         bb.bb_val.bv_val = NULL;
 180         bb.bb_val.bv_len = 0;
 181         bb.bb_len = 0;
 182         backsql_strfcat( &bb, "lbcbll",
 183                         (ber_len_t)sizeof( "ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=" ) - 1,
 184                                 "ldap_entries.id=ldap_referrals.entry_id and ldap_entries.keyval=",
 185                         &oc_map->bom_keytbl,
 186                         '.',
 187                         &oc_map->bom_keycol,
 188                         (ber_len_t)sizeof( " and ldap_entries.oc_map_id=" ) - 1,
 189                                 " and ldap_entries.oc_map_id=",
 190                         slen, s );
 191
 192         at_map->bam_oc = NULL;
 193         at_map->bam_join_where = bb.bb_val;
 194         at_map->bam_add_proc = NULL;
 195         at_map->bam_delete_proc = NULL;
 196         at_map->bam_param_order = 0;
 197         at_map->bam_expect_return = 0;
 198         at_map->bam_next = NULL;
 199
 200         backsql_make_attr_query( oc_map, at_map );
 201         if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 202                 Debug( LDAP_DEBUG_TRACE, "backsql_add_sysmaps(): "
 203                                 "duplicate attribute \"%s\" in objectClass \"%s\" map\n",
 204                                 at_map->bam_ad->ad_cname.bv_val,
 205                                 oc_map->bom_oc->soc_cname.bv_val, 0 );
 206         }
 207
 208         return 1;
 209 }
 210
 211 int
 212 backsql_load_schema_map( backsql_info *si, SQLHDBC dbh )
 213 {
 214         SQLHSTMT                oc_sth, at_sth;
 215         RETCODE                 rc;
 216         BACKSQL_ROW_NTS         oc_row, at_row;
 217         unsigned long           oc_id;
 218         backsql_oc_map_rec      *oc_map;
 219         backsql_at_map_rec      *at_map;
 220
 221         Debug( LDAP_DEBUG_TRACE, "==>load_schema_map()\n", 0, 0, 0 );
 222
 223         /*
 224          * TimesTen : See if the ldap_entries.dn_ru field exists in the schema
 225          */
 226         if ( !BACKSQL_DONTCHECK_LDAPINFO_DN_RU( si ) ) {
 227                 rc = backsql_Prepare( dbh, &oc_sth,
 228                                 backsql_check_dn_ru_query, 0 );
 229                 if ( rc == SQL_SUCCESS ) {
 230                         /* Yes, the field exists */
 231                         si->bsql_flags |= BSQLF_HAS_LDAPINFO_DN_RU;
 232                         Debug( LDAP_DEBUG_TRACE, "ldapinfo.dn_ru field exists "
 233                                 "in the schema\n", 0, 0, 0 );
 234                 } else {
 235                         /* No such field exists */
 236                         si->bsql_flags &= ~BSQLF_HAS_LDAPINFO_DN_RU;
 237                 }
 238
 239                 SQLFreeStmt( oc_sth, SQL_DROP );
 240         }
 241
 242
 243         rc = backsql_Prepare( dbh, &oc_sth, si->oc_query, 0 );
 244         if ( rc != SQL_SUCCESS ) {
 245                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 246                         "error preparing oc_query: '%s'\n",
 247                         si->oc_query, 0, 0 );
 248                 backsql_PrintErrors( si->db_env, dbh, oc_sth, rc );
 249                 return LDAP_OTHER;
 250         }
 251         Debug( LDAP_DEBUG_TRACE, "load_schema_map(): at_query '%s'\n",
 252                         si->at_query, 0, 0 );
 253
 254         rc = backsql_Prepare( dbh, &at_sth, si->at_query, 0 );
 255         if ( rc != SQL_SUCCESS ) {
 256                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 257                         "error preparing at_query: '%s'\n",
 258                         si->at_query, 0, 0 );
 259                 backsql_PrintErrors( si->db_env, dbh, at_sth, rc );
 260                 return LDAP_OTHER;
 261         }
 262
 263         rc = backsql_BindParamID( at_sth, 1, &oc_id );
 264         if ( rc != SQL_SUCCESS ) {
 265                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 266                         "error binding param for at_query: \n", 0, 0, 0 );
 267                 backsql_PrintErrors( si->db_env, dbh, at_sth, rc );
 268                 return LDAP_OTHER;
 269         }
 270
 271         rc = SQLExecute( oc_sth );
 272         if ( rc != SQL_SUCCESS ) {
 273                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 274                         "error executing oc_query: \n", 0, 0, 0 );
 275                 backsql_PrintErrors( si->db_env, dbh, oc_sth, rc );
 276                 return LDAP_OTHER;
 277         }
 278
 279         backsql_BindRowAsStrings( oc_sth, &oc_row );
 280         rc = SQLFetch( oc_sth );
 281         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( oc_sth ) ) {
 282                 int     colnum;
 283
 284                 oc_map = (backsql_oc_map_rec *)ch_calloc( 1,
 285                                 sizeof( backsql_oc_map_rec ) );
 286
 287                 oc_map->bom_id = strtol( oc_row.cols[ 0 ], NULL, 0 );
 288
 289                 oc_map->bom_oc = oc_find( oc_row.cols[ 1 ] );
 290                 if ( oc_map->bom_oc == NULL ) {
 291                         Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 292                                 "objectClass '%s' is not defined in schema\n",
 293                                 oc_row.cols[ 1 ], 0, 0 );
 294                         return LDAP_OTHER;      /* undefined objectClass ? */
 295                 }
 296
 297                 ber_str2bv( oc_row.cols[ 2 ], 0, 1, &oc_map->bom_keytbl );
 298                 ber_str2bv( oc_row.cols[ 3 ], 0, 1, &oc_map->bom_keycol );
 299                 oc_map->bom_create_proc = ( oc_row.value_len[ 4 ] < 0 ) ? NULL
 300                         : ch_strdup( oc_row.cols[ 4 ] );
 301
 302                 colnum = 5;
 303                 if ( BACKSQL_CREATE_NEEDS_SELECT( si ) ) {
 304                         colnum = 6;
 305                         oc_map->bom_create_keyval = ( oc_row.value_len[ 5 ] < 0 )
 306                                 ? NULL : ch_strdup( oc_row.cols[ 5 ] );
 307                 }
 308                 oc_map->bom_delete_proc = ( oc_row.value_len[ colnum ] < 0 ) ? NULL
 309                         : ch_strdup( oc_row.cols[ colnum ] );
 310                 oc_map->bom_expect_return = strtol( oc_row.cols[ colnum + 1 ],
 311                                 NULL, 0 );
 312
 313                 /*
 314                  * FIXME: first attempt to check for offending
 315                  * instructions in {create|delete}_proc
 316                  */
 317
 318                 oc_map->bom_attrs = NULL;
 319                 if ( avl_insert( &si->oc_by_oc, oc_map, backsql_cmp_oc, avl_dup_error ) == -1 ) {
 320                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 321                                         "duplicate objectClass \"%s\" in objectClass map\n",
 322                                         oc_map->bom_oc->soc_cname.bv_val, 0, 0 );
 323                         return LDAP_OTHER;
 324                 }
 325                 if ( avl_insert( &si->oc_by_id, oc_map, backsql_cmp_oc_id, avl_dup_error ) == -1 ) {
 326                         Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 327                                         "duplicate objectClass \"%s\" in objectClass by ID map\n",
 328                                         oc_map->bom_oc->soc_cname.bv_val, 0, 0 );
 329                         return LDAP_OTHER;
 330                 }
 331                 oc_id = oc_map->bom_id;
 332                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 333                         "objectClass '%s': keytbl='%s' keycol='%s'\n",
 334                         BACKSQL_OC_NAME( oc_map ),
 335                         oc_map->bom_keytbl.bv_val, oc_map->bom_keycol.bv_val );
 336                 if ( oc_map->bom_create_proc ) {
 337                         Debug( LDAP_DEBUG_TRACE, "create_proc='%s'\n",
 338                                 oc_map->bom_create_proc, 0, 0 );
 339                 }
 340                 if ( oc_map->bom_create_keyval ) {
 341                         Debug( LDAP_DEBUG_TRACE, "create_keyval='%s'\n",
 342                                 oc_map->bom_create_keyval, 0, 0 );
 343                 }
 344                 if ( oc_map->bom_delete_proc ) {
 345                         Debug( LDAP_DEBUG_TRACE, "delete_proc='%s'\n",
 346                                 oc_map->bom_delete_proc, 0, 0 );
 347                 }
 348                 Debug( LDAP_DEBUG_TRACE, "expect_return: "
 349                         "add=%d, del=%d; attributes:\n",
 350                         BACKSQL_IS_ADD( oc_map->bom_expect_return ),
 351                         BACKSQL_IS_DEL( oc_map->bom_expect_return ), 0 );
 352
 353                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 354                         "autoadding 'objectClass' and 'ref' mappings\n",
 355                         0, 0, 0 );
 356                 backsql_add_sysmaps( oc_map );
 357                 rc = SQLExecute( at_sth );
 358                 if ( rc != SQL_SUCCESS ) {
 359                         Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 360                                 "error executing at_query: \n", 0, 0, 0 );
 361                         backsql_PrintErrors( SQL_NULL_HENV, dbh, at_sth, rc );
 362                         return LDAP_OTHER;
 363                 }
 364
 365                 backsql_BindRowAsStrings( at_sth, &at_row );
 366                 rc = SQLFetch( at_sth );
 367                 for ( ; BACKSQL_SUCCESS(rc); rc = SQLFetch( at_sth ) ) {
 368                         const char      *text = NULL;
 369                         struct berval   bv;
 370                         struct berbuf   bb = BB_NULL;
 371
 372                         Debug( LDAP_DEBUG_TRACE, "********'%s'\n",
 373                                 at_row.cols[ 0 ], 0, 0 );
 374                         Debug( LDAP_DEBUG_TRACE,
 375                                 "name='%s',sel_expr='%s' from='%s'",
 376                                 at_row.cols[ 0 ], at_row.cols[ 1 ],
 377                                 at_row.cols[ 2 ] );
 378                         Debug( LDAP_DEBUG_TRACE,
 379                                 "join_where='%s',add_proc='%s'",
 380                                 at_row.cols[ 3 ], at_row.cols[ 4 ], 0 );
 381                         Debug( LDAP_DEBUG_TRACE, "delete_proc='%s'\n",
 382                                         at_row.cols[ 5 ], 0, 0 );
 383                         /* TimesTen */
 384                         Debug( LDAP_DEBUG_TRACE, "sel_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, "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, "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                 backsql_FreeRow( &at_row );
 444                 SQLFreeStmt( at_sth, SQL_CLOSE );
 445         }
 446         backsql_FreeRow( &oc_row );
 447         SQLFreeStmt( at_sth, SQL_DROP );
 448         SQLFreeStmt( oc_sth, SQL_DROP );
 449         si->bsql_flags |= BSQLF_SCHEMA_LOADED;
 450         Debug( LDAP_DEBUG_TRACE, "<==load_schema_map()\n", 0, 0, 0 );
 451         return LDAP_SUCCESS;
 452 }
 453
 454 backsql_oc_map_rec *
 455 backsql_oc2oc( backsql_info *si, ObjectClass *oc )
 456 {
 457         backsql_oc_map_rec      tmp, *res;
 458
 459 #ifdef BACKSQL_TRACE
 460         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc2oc(): "
 461                 "searching for objectclass with name='%s'\n",
 462                 objclass, 0, 0 );
 463 #endif /* BACKSQL_TRACE */
 464
 465         tmp.bom_oc = oc;
 466         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 467 #ifdef BACKSQL_TRACE
 468         if ( res != NULL ) {
 469                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 470                         "found name='%s', id=%d\n",
 471                         BACKSQL_OC_NAME( res ), res->id, 0 );
 472         } else {
 473                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 474                         "not found\n", 0, 0, 0 );
 475         }
 476 #endif /* BACKSQL_TRACE */
 477
 478         return res;
 479 }
 480
 481 backsql_oc_map_rec *
 482 backsql_name2oc( backsql_info *si, struct berval *oc_name )
 483 {
 484         backsql_oc_map_rec      tmp, *res;
 485
 486 #ifdef BACKSQL_TRACE
 487         Debug( LDAP_DEBUG_TRACE, "==>oc_with_name(): "
 488                 "searching for objectclass with name='%s'\n",
 489                 objclass, 0, 0 );
 490 #endif /* BACKSQL_TRACE */
 491
 492         tmp.bom_oc = oc_bvfind( oc_name );
 493         if ( tmp.bom_oc == NULL ) {
 494                 return NULL;
 495         }
 496
 497         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 498 #ifdef BACKSQL_TRACE
 499         if ( res != NULL ) {
 500                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 501                         "found name='%s', id=%d\n",
 502                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 503         } else {
 504                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 505                         "not found\n", 0, 0, 0 );
 506         }
 507 #endif /* BACKSQL_TRACE */
 508
 509         return res;
 510 }
 511
 512 backsql_oc_map_rec *
 513 backsql_id2oc( backsql_info *si, unsigned long id )
 514 {
 515         backsql_oc_map_rec      tmp, *res;
 516
 517 #ifdef BACKSQL_TRACE
 518         Debug( LDAP_DEBUG_TRACE, "==>oc_with_id(): "
 519                 "searching for objectclass with id='%d'\n", id, 0, 0 );
 520 #endif /* BACKSQL_TRACE */
 521
 522         tmp.bom_id = id;
 523         res = (backsql_oc_map_rec *)avl_find( si->oc_by_id, &tmp,
 524                         backsql_cmp_oc_id );
 525
 526 #ifdef BACKSQL_TRACE
 527         if ( res != NULL ) {
 528                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 529                         "found name='%s', id=%d\n",
 530                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 531         } else {
 532                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 533                         "not found\n", 0, 0, 0 );
 534         }
 535 #endif /* BACKSQL_TRACE */
 536
 537         return res;
 538 }
 539
 540 backsql_at_map_rec *
 541 backsql_ad2at( backsql_oc_map_rec* objclass, AttributeDescription *ad )
 542 {
 543         backsql_at_map_rec      tmp, *res;
 544
 545 #ifdef BACKSQL_TRACE
 546         Debug( LDAP_DEBUG_TRACE, "==>backsql_ad2at(): "
 547                 "searching for attribute '%s' for objectclass '%s'\n",
 548                 attr, BACKSQL_OC_NAME( objclass ), 0 );
 549 #endif /* BACKSQL_TRACE */
 550
 551         tmp.bam_ad = ad;
 552         res = (backsql_at_map_rec *)avl_find( objclass->bom_attrs, &tmp,
 553                         backsql_cmp_attr );
 554
 555 #ifdef BACKSQL_TRACE
 556         if ( res != NULL ) {
 557                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 558                         "found name='%s', sel_expr='%s'\n",
 559                         res->bam_ad->ad_cname.bv_val,
 560                         res->bam_sel_expr.bv_val, 0 );
 561         } else {
 562                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 563                         "not found\n", 0, 0, 0 );
 564         }
 565 #endif /* BACKSQL_TRACE */
 566
 567         return res;
 568 }
 569
 570 /* attributeType inheritance */
 571 struct supad2at_t {
 572         backsql_at_map_rec      **ret;
 573         AttributeDescription    *ad;
 574         unsigned                n;
 575 };
 576
 577 #define SUPAD2AT_STOP   (-1)
 578
 579 static int
 580 supad2at_f( void *v_at, void *v_arg )
 581 {
 582         backsql_at_map_rec      *at = (backsql_at_map_rec *)v_at;
 583         struct supad2at_t       *va = (struct supad2at_t *)v_arg;
 584
 585         if ( is_at_subtype( at->bam_ad->ad_type, va->ad->ad_type ) ) {
 586                 backsql_at_map_rec      **ret;
 587
 588                 ret = ch_realloc( va->ret, sizeof( backsql_at_map_rec *) * ( va->n + 2 ) );
 589                 if ( ret == NULL ) {
 590                         ch_free( va->ret );
 591                         return SUPAD2AT_STOP;
 592                 }
 593
 594                 ret[ va->n ] = at;
 595                 va->n++;
 596                 ret[ va->n ] = NULL;
 597                 va->ret = ret;
 598         }
 599
 600         return 0;
 601 }
 602
 603 /*
 604  * stores in *pret a NULL terminated array of pointers
 605  * to backsql_at_map_rec whose attributeType is supad->ad_type
 606  * or derived from it
 607  */
 608 int
 609 backsql_supad2at( backsql_oc_map_rec *objclass, AttributeDescription *supad,
 610                 backsql_at_map_rec ***pret )
 611 {
 612         struct supad2at_t       va;
 613         int                     rc;
 614
 615         assert( objclass );
 616         assert( supad );
 617         assert( pret );
 618
 619         *pret = NULL;
 620
 621         va.ret = NULL;
 622         va.ad = supad;
 623         va.n = 0;
 624
 625         rc = avl_apply( objclass->bom_attrs, supad2at_f, &va,
 626                         SUPAD2AT_STOP, AVL_INORDER );
 627         if ( rc == SUPAD2AT_STOP ) {
 628                 return -1;
 629         }
 630
 631         *pret = va.ret;
 632
 633         return 0;
 634 }
 635
 636 static void
 637 backsql_free_attr( void *v_at )
 638 {
 639         backsql_at_map_rec      *at = v_at;
 640
 641         Debug( LDAP_DEBUG_TRACE, "==>free_attr(): '%s'\n",
 642                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 643         ch_free( at->bam_sel_expr.bv_val );
 644         if ( at->bam_from_tbls.bv_val != NULL ) {
 645                 ch_free( at->bam_from_tbls.bv_val );
 646         }
 647         if ( at->bam_join_where.bv_val != NULL ) {
 648                 ch_free( at->bam_join_where.bv_val );
 649         }
 650         if ( at->bam_add_proc != NULL ) {
 651                 ch_free( at->bam_add_proc );
 652         }
 653         if ( at->bam_delete_proc != NULL ) {
 654                 ch_free( at->bam_delete_proc );
 655         }
 656         if ( at->bam_query ) {
 657                 ch_free( at->bam_query );
 658         }
 659
 660         /* TimesTen */
 661         if ( at->bam_sel_expr_u.bv_val ) {
 662                 ch_free( at->bam_sel_expr_u.bv_val );
 663         }
 664
 665         if ( at->bam_next ) {
 666                 backsql_free_attr( at->bam_next );
 667         }
 668
 669         ch_free( at );
 670
 671         Debug( LDAP_DEBUG_TRACE, "<==free_attr()\n", 0, 0, 0 );
 672 }
 673
 674 static void
 675 backsql_free_oc( void *v_oc )
 676 {
 677         backsql_oc_map_rec      *oc = v_oc;
 678
 679         Debug( LDAP_DEBUG_TRACE, "==>free_oc(): '%s'\n",
 680                         BACKSQL_OC_NAME( oc ), 0, 0 );
 681         avl_free( oc->bom_attrs, backsql_free_attr );
 682         ch_free( oc->bom_keytbl.bv_val );
 683         ch_free( oc->bom_keycol.bv_val );
 684         if ( oc->bom_create_proc != NULL ) {
 685                 ch_free( oc->bom_create_proc );
 686         }
 687         if ( oc->bom_create_keyval != NULL ) {
 688                 ch_free( oc->bom_create_keyval );
 689         }
 690         if ( oc->bom_delete_proc != NULL ) {
 691                 ch_free( oc->bom_delete_proc );
 692         }
 693         ch_free( oc );
 694
 695         Debug( LDAP_DEBUG_TRACE, "<==free_oc()\n", 0, 0, 0 );
 696 }
 697
 698 int
 699 backsql_destroy_schema_map( backsql_info *si )
 700 {
 701         Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n", 0, 0, 0 );
 702         avl_free( si->oc_by_oc, 0 );
 703         avl_free( si->oc_by_id, backsql_free_oc );
 704         Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n", 0, 0, 0 );
 705         return 0;
 706 }
 707
 708 #endif /* SLAPD_SQL */
 709