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, "==>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, "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, "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, "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, "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, "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, "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, "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, "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, "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, "********'%s'\n",
 371                                 at_row.cols[ 0 ], 0, 0 );
 372                         Debug( LDAP_DEBUG_TRACE,
 373                                 "name='%s',sel_expr='%s' from='%s'",
 374                                 at_row.cols[ 0 ], at_row.cols[ 1 ],
 375                                 at_row.cols[ 2 ] );
 376                         Debug( LDAP_DEBUG_TRACE,
 377                                 "join_where='%s',add_proc='%s'",
 378                                 at_row.cols[ 3 ], at_row.cols[ 4 ], 0 );
 379                         Debug( LDAP_DEBUG_TRACE, "delete_proc='%s'\n",
 380                                         at_row.cols[ 5 ], 0, 0 );
 381                         /* TimesTen */
 382                         Debug( LDAP_DEBUG_TRACE, "sel_expr_u='%s'\n",
 383                                         at_row.cols[ 8 ], 0, 0 );
 384                         at_map = (backsql_at_map_rec *)ch_calloc( 1,
 385                                         sizeof( backsql_at_map_rec ) );
 386                         rc = slap_str2ad( at_row.cols[ 0 ],
 387                                         &at_map->bam_ad, &text );
 388                         if ( rc != LDAP_SUCCESS ) {
 389                                 Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 390                                         "attribute '%s' for objectClass '%s' "
 391                                         "is not defined in schema: %s\n",
 392                                         at_row.cols[ 0 ],
 393                                         BACKSQL_OC_NAME( oc_map ), text );
 394                                 return LDAP_CONSTRAINT_VIOLATION;
 395                         }
 396
 397                         ber_str2bv( at_row.cols[ 1 ], 0, 1, &at_map->bam_sel_expr );
 398                         if ( at_row.value_len[ 8 ] < 0 ) {
 399                                 at_map->bam_sel_expr_u.bv_val = NULL;
 400                                 at_map->bam_sel_expr_u.bv_len = 0;
 401                         } else {
 402                                 ber_str2bv( at_row.cols[ 8 ], 0, 1,
 403                                                 &at_map->bam_sel_expr_u );
 404                         }
 405
 406                         ber_str2bv( at_row.cols[ 2 ], 0, 0, &bv );
 407                         backsql_merge_from_clause( &bb, &bv );
 408                         at_map->bam_from_tbls = bb.bb_val;
 409                         if ( at_row.value_len[ 3 ] < 0 ) {
 410                                 at_map->bam_join_where.bv_val = NULL;
 411                                 at_map->bam_join_where.bv_len = 0;
 412                         } else {
 413                                 ber_str2bv( at_row.cols[ 3 ], 0, 1,
 414                                                 &at_map->bam_join_where );
 415                         }
 416                         at_map->bam_add_proc = NULL;
 417                         if ( at_row.value_len[ 4 ] > 0 ) {
 418                                 at_map->bam_add_proc = ch_strdup( at_row.cols[4] );
 419                         }
 420                         at_map->bam_delete_proc = NULL;
 421                         if ( at_row.value_len[ 5 ] > 0 ) {
 422                                 at_map->bam_delete_proc = ch_strdup( at_row.cols[ 5 ] );
 423                         }
 424                         at_map->bam_param_order = strtol( at_row.cols[ 6 ],
 425                                         NULL, 0 );
 426                         at_map->bam_expect_return = strtol( at_row.cols[ 7 ],
 427                                         NULL, 0 );
 428                         backsql_make_attr_query( oc_map, at_map );
 429                         Debug( LDAP_DEBUG_TRACE, "load_schema_map(): "
 430                                 "preconstructed query '%s'\n",
 431                                 at_map->bam_query, 0, 0 );
 432                         at_map->bam_next = NULL;
 433                         if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
 434                                 Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
 435                                                 "duplicate attribute \"%s\" "
 436                                                 "in objectClass \"%s\" map\n",
 437                                                 at_map->bam_ad->ad_cname.bv_val,
 438                                                 oc_map->bom_oc->soc_cname.bv_val, 0 );
 439                         }
 440
 441                         if ( si->upper_func.bv_val && at_map->bam_sel_expr_u.bv_val == NULL ) {
 442                                 struct berbuf   bb = BB_NULL;
 443
 444                                 backsql_strfcat( &bb, "bcbc",
 445                                                 &si->upper_func,
 446                                                 '(' /* ) */ ,
 447                                                 &at_map->bam_sel_expr,
 448                                                 /* ( */ ')' );
 449                                 at_map->bam_sel_expr_u = bb.bb_val;
 450                         }
 451                 }
 452                 backsql_FreeRow( &at_row );
 453                 SQLFreeStmt( at_sth, SQL_CLOSE );
 454         }
 455         backsql_FreeRow( &oc_row );
 456         SQLFreeStmt( at_sth, SQL_DROP );
 457         SQLFreeStmt( oc_sth, SQL_DROP );
 458         si->bsql_flags |= BSQLF_SCHEMA_LOADED;
 459         Debug( LDAP_DEBUG_TRACE, "<==load_schema_map()\n", 0, 0, 0 );
 460         return LDAP_SUCCESS;
 461 }
 462
 463 backsql_oc_map_rec *
 464 backsql_oc2oc( backsql_info *si, ObjectClass *oc )
 465 {
 466         backsql_oc_map_rec      tmp, *res;
 467
 468 #ifdef BACKSQL_TRACE
 469         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc2oc(): "
 470                 "searching for objectclass with name='%s'\n",
 471                 objclass, 0, 0 );
 472 #endif /* BACKSQL_TRACE */
 473
 474         tmp.bom_oc = oc;
 475         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 476 #ifdef BACKSQL_TRACE
 477         if ( res != NULL ) {
 478                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 479                         "found name='%s', id=%d\n",
 480                         BACKSQL_OC_NAME( res ), res->id, 0 );
 481         } else {
 482                 Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
 483                         "not found\n", 0, 0, 0 );
 484         }
 485 #endif /* BACKSQL_TRACE */
 486
 487         return res;
 488 }
 489
 490 backsql_oc_map_rec *
 491 backsql_name2oc( backsql_info *si, struct berval *oc_name )
 492 {
 493         backsql_oc_map_rec      tmp, *res;
 494
 495 #ifdef BACKSQL_TRACE
 496         Debug( LDAP_DEBUG_TRACE, "==>oc_with_name(): "
 497                 "searching for objectclass with name='%s'\n",
 498                 objclass, 0, 0 );
 499 #endif /* BACKSQL_TRACE */
 500
 501         tmp.bom_oc = oc_bvfind( oc_name );
 502         if ( tmp.bom_oc == NULL ) {
 503                 return NULL;
 504         }
 505
 506         res = (backsql_oc_map_rec *)avl_find( si->oc_by_oc, &tmp, backsql_cmp_oc );
 507 #ifdef BACKSQL_TRACE
 508         if ( res != NULL ) {
 509                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 510                         "found name='%s', id=%d\n",
 511                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 512         } else {
 513                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 514                         "not found\n", 0, 0, 0 );
 515         }
 516 #endif /* BACKSQL_TRACE */
 517
 518         return res;
 519 }
 520
 521 backsql_oc_map_rec *
 522 backsql_id2oc( backsql_info *si, unsigned long id )
 523 {
 524         backsql_oc_map_rec      tmp, *res;
 525
 526 #ifdef BACKSQL_TRACE
 527         Debug( LDAP_DEBUG_TRACE, "==>oc_with_id(): "
 528                 "searching for objectclass with id='%d'\n", id, 0, 0 );
 529 #endif /* BACKSQL_TRACE */
 530
 531         tmp.bom_id = id;
 532         res = (backsql_oc_map_rec *)avl_find( si->oc_by_id, &tmp,
 533                         backsql_cmp_oc_id );
 534
 535 #ifdef BACKSQL_TRACE
 536         if ( res != NULL ) {
 537                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 538                         "found name='%s', id=%d\n",
 539                         BACKSQL_OC_NAME( res ), res->bom_id, 0 );
 540         } else {
 541                 Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
 542                         "not found\n", 0, 0, 0 );
 543         }
 544 #endif /* BACKSQL_TRACE */
 545
 546         return res;
 547 }
 548
 549 backsql_at_map_rec *
 550 backsql_ad2at( backsql_oc_map_rec* objclass, AttributeDescription *ad )
 551 {
 552         backsql_at_map_rec      tmp, *res;
 553
 554 #ifdef BACKSQL_TRACE
 555         Debug( LDAP_DEBUG_TRACE, "==>backsql_ad2at(): "
 556                 "searching for attribute '%s' for objectclass '%s'\n",
 557                 attr, BACKSQL_OC_NAME( objclass ), 0 );
 558 #endif /* BACKSQL_TRACE */
 559
 560         tmp.bam_ad = ad;
 561         res = (backsql_at_map_rec *)avl_find( objclass->bom_attrs, &tmp,
 562                         backsql_cmp_attr );
 563
 564 #ifdef BACKSQL_TRACE
 565         if ( res != NULL ) {
 566                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 567                         "found name='%s', sel_expr='%s'\n",
 568                         res->bam_ad->ad_cname.bv_val,
 569                         res->bam_sel_expr.bv_val, 0 );
 570         } else {
 571                 Debug( LDAP_DEBUG_TRACE, "<==backsql_ad2at(): "
 572                         "not found\n", 0, 0, 0 );
 573         }
 574 #endif /* BACKSQL_TRACE */
 575
 576         return res;
 577 }
 578
 579 /* attributeType inheritance */
 580 struct supad2at_t {
 581         backsql_at_map_rec      **ret;
 582         AttributeDescription    *ad;
 583         unsigned                n;
 584 };
 585
 586 #define SUPAD2AT_STOP   (-1)
 587
 588 static int
 589 supad2at_f( void *v_at, void *v_arg )
 590 {
 591         backsql_at_map_rec      *at = (backsql_at_map_rec *)v_at;
 592         struct supad2at_t       *va = (struct supad2at_t *)v_arg;
 593
 594         if ( is_at_subtype( at->bam_ad->ad_type, va->ad->ad_type ) ) {
 595                 backsql_at_map_rec      **ret;
 596
 597                 ret = ch_realloc( va->ret, sizeof( backsql_at_map_rec *) * ( va->n + 2 ) );
 598                 if ( ret == NULL ) {
 599                         ch_free( va->ret );
 600                         return SUPAD2AT_STOP;
 601                 }
 602
 603                 ret[ va->n ] = at;
 604                 va->n++;
 605                 ret[ va->n ] = NULL;
 606                 va->ret = ret;
 607         }
 608
 609         return 0;
 610 }
 611
 612 /*
 613  * stores in *pret a NULL terminated array of pointers
 614  * to backsql_at_map_rec whose attributeType is supad->ad_type
 615  * or derived from it
 616  */
 617 int
 618 backsql_supad2at( backsql_oc_map_rec *objclass, AttributeDescription *supad,
 619                 backsql_at_map_rec ***pret )
 620 {
 621         struct supad2at_t       va;
 622         int                     rc;
 623
 624         assert( objclass );
 625         assert( supad );
 626         assert( pret );
 627
 628         *pret = NULL;
 629
 630         va.ret = NULL;
 631         va.ad = supad;
 632         va.n = 0;
 633
 634         rc = avl_apply( objclass->bom_attrs, supad2at_f, &va,
 635                         SUPAD2AT_STOP, AVL_INORDER );
 636         if ( rc == SUPAD2AT_STOP ) {
 637                 return -1;
 638         }
 639
 640         *pret = va.ret;
 641
 642         return 0;
 643 }
 644
 645 static void
 646 backsql_free_attr( void *v_at )
 647 {
 648         backsql_at_map_rec      *at = v_at;
 649
 650         Debug( LDAP_DEBUG_TRACE, "==>free_attr(): '%s'\n",
 651                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 652         ch_free( at->bam_sel_expr.bv_val );
 653         if ( at->bam_from_tbls.bv_val != NULL ) {
 654                 ch_free( at->bam_from_tbls.bv_val );
 655         }
 656         if ( at->bam_join_where.bv_val != NULL ) {
 657                 ch_free( at->bam_join_where.bv_val );
 658         }
 659         if ( at->bam_add_proc != NULL ) {
 660                 ch_free( at->bam_add_proc );
 661         }
 662         if ( at->bam_delete_proc != NULL ) {
 663                 ch_free( at->bam_delete_proc );
 664         }
 665         if ( at->bam_query ) {
 666                 ch_free( at->bam_query );
 667         }
 668
 669         /* TimesTen */
 670         if ( at->bam_sel_expr_u.bv_val ) {
 671                 ch_free( at->bam_sel_expr_u.bv_val );
 672         }
 673
 674         if ( at->bam_next ) {
 675                 backsql_free_attr( at->bam_next );
 676         }
 677
 678         ch_free( at );
 679
 680         Debug( LDAP_DEBUG_TRACE, "<==free_attr()\n", 0, 0, 0 );
 681 }
 682
 683 static void
 684 backsql_free_oc( void *v_oc )
 685 {
 686         backsql_oc_map_rec      *oc = v_oc;
 687
 688         Debug( LDAP_DEBUG_TRACE, "==>free_oc(): '%s'\n",
 689                         BACKSQL_OC_NAME( oc ), 0, 0 );
 690         avl_free( oc->bom_attrs, backsql_free_attr );
 691         ch_free( oc->bom_keytbl.bv_val );
 692         ch_free( oc->bom_keycol.bv_val );
 693         if ( oc->bom_create_proc != NULL ) {
 694                 ch_free( oc->bom_create_proc );
 695         }
 696         if ( oc->bom_create_keyval != NULL ) {
 697                 ch_free( oc->bom_create_keyval );
 698         }
 699         if ( oc->bom_delete_proc != NULL ) {
 700                 ch_free( oc->bom_delete_proc );
 701         }
 702         ch_free( oc );
 703
 704         Debug( LDAP_DEBUG_TRACE, "<==free_oc()\n", 0, 0, 0 );
 705 }
 706
 707 int
 708 backsql_destroy_schema_map( backsql_info *si )
 709 {
 710         Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n", 0, 0, 0 );
 711         avl_free( si->oc_by_oc, 0 );
 712         avl_free( si->oc_by_id, backsql_free_oc );
 713         Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n", 0, 0, 0 );
 714         return 0;
 715 }
 716
 717 #endif /* SLAPD_SQL */
 718