text: /* $OpenLDAP$ */
  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   *
   * Copyright 1999-2021 The OpenLDAP Foundation.
   * Portions Copyright 1999 Dmitry Kovalev.
   * Portions Copyright 2002 Pierangelo Mararati.
   * Portions Copyright 2004 Mark Adamson.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted only as authorized by the OpenLDAP
   * Public License.
   *
   * A copy of this license is available in the file LICENSE in the
   * top-level directory of the distribution or, alternatively, at
   * <http://www.OpenLDAP.org/license.html>.
   */
  /* ACKNOWLEDGEMENTS:
   * This work was initially developed by Dmitry Kovalev for inclusion
   * by OpenLDAP Software.  Additional significant contributors include
   * Pierangelo Masarati and Mark Adamson.
   */
  /*
   * The following changes have been addressed:
   *	 
   * Enhancements:
   *   - re-styled code for better readability
   *   - upgraded backend API to reflect recent changes
   *   - LDAP schema is checked when loading SQL/LDAP mapping
   *   - AttributeDescription/ObjectClass pointers used for more efficient
   *     mapping lookup
   *   - bervals used where string length is required often
   *   - atomized write operations by committing at the end of each operation
   *     and defaulting connection closure to rollback
   *   - added LDAP access control to write operations
   *   - fully implemented modrdn (with rdn attrs change, deleteoldrdn,
   *     access check, parent/children check and more)
   *   - added parent access control, children control to delete operation
   *   - added structuralObjectClass operational attribute check and
   *     value return on search
   *   - added hasSubordinate operational attribute on demand
   *   - search limits are appropriately enforced
   *   - function backsql_strcat() has been made more efficient
   *   - concat function has been made configurable by means of a pattern
   *   - added config switches:
   *       - fail_if_no_mapping	write operations fail if there is no mapping
   *       - has_ldapinfo_dn_ru	overrides autodetect
   *       - concat_pattern	a string containing two '?' is used
   * 				(note that "?||?" should be more portable
   * 				than builtin function "CONCAT(?,?)")
   *       - strcast_func		cast of string constants in "SELECT DISTINCT
   *				statements (needed by PostgreSQL)
   *       - upper_needs_cast	cast the argument of upper when required
   * 				(basically when building dn substring queries)
   *   - added noop control
   *   - added values return filter control
   *   - hasSubordinate can be used in search filters (with limitations)
   *   - eliminated oc->name; use oc->oc->soc_cname instead
   * 
   * Todo:
   *   - add security checks for SQL statements that can be injected (?)
   *   - re-test with previously supported RDBMs
   *   - replace dn_ru and so with normalized dn (no need for upper() and so
   *     in dn match)
   *   - implement a backsql_normalize() function to replace the upper()
   *     conversion routines
   *   - note that subtree deletion, subtree renaming and so could be easily
   *     implemented (rollback and consistency checks are available :)
   *   - implement "lastmod" and other operational stuff (ldap_entries table ?)
   *   - check how to allow multiple operations with one statement, to remove
   *     BACKSQL_REALLOC_STMT from modify.c (a more recent unixODBC lib?)
   */
  /*
   * Improvements submitted by (ITS#3432)
   *
   * 1. id_query.patch		applied (with changes)
   * 2. shortcut.patch		applied (reworked)
   * 3. create_hint.patch		applied
   * 4. count_query.patch		applied (reworked)
   * 5. returncodes.patch		applied (with sanity checks)
   * 6. connpool.patch		under evaluation
   * 7. modoc.patch		under evaluation (requires
   * 				manageDSAit and "manage"
   * 				access privileges)
   * 8. miscfixes.patch		applied (reworked; other
   *				operations need to load the
   *				entire entry for ACL purposes;
   *				see ITS#3480, now fixed)
   *
   * original description:
  
           Changes that were made to the SQL backend.
  
  The patches were made against 2.2.18 and can be applied individually,
  but would best be applied in the numerical order of the file names.
  A synopsis of each patch is given here:
  
  
  1. Added an option to set SQL query for the "id_query" operation.
  
  2. Added an option to the SQL backend called "use_subtree_shortcut".
  When a search is performed, the SQL query includes a WHERE clause
  which says the DN must be "LIKE %<searchbase>".  The LIKE operation
  can be slow in an RDBM. This shortcut option says that if the
  searchbase of the LDAP search is the root DN of the SQL backend,
  and thus all objects will match the LIKE operator, do not include
  the "LIKE %<searchbase>" clause in the SQL query (it is replaced
  instead by the always true "1=1" clause to keep the "AND"'s 
  working correctly).  This option is off by default, and should be
  turned on only if all objects to be found in the RDBM are under the
  same root DN. Multiple backends working within the same RDBM table
  space would encounter problems. LDAP searches whose searchbase are
  not at the root DN will bypass this shortcut and employ the LIKE 
  clause.
  
  3. Added a "create_hint" column to ldap_oc_mappings table. Allows
  taking the value of an attr named in "create_hint" and passing it to
  the create_proc procedure.  This is necessary for when an objectClass's
  table is partition indexed by some indexing column and thus the value
  in that indexing column cannot change after the row is created. The
  value for the indexed column is passed into the create_proc, which
  uses it to fill in the indexed column as the new row is created.
  
  4. When loading the values of an attribute, the count(*) of the number
  of values is fetched first and memory is allocated for the array of
  values and normalized values. The old system of loading the values one
  by one and running realloc() on the array of values and normalized
  values each time was badly fragmenting memory. The array of values and
  normalized values would be side by side in memory, and realloc()'ing
  them over and over would force them to leapfrog each other through all
  of available memory. Attrs with a large number of values could not be
  loaded without crashing the slapd daemon.
  
  5. Added code to interpret the value returned by stored procedures
  which have expect_return set. Returned value is interpreted as an LDAP
  return code. This allows the distinction between the SQL failing to
  execute and the SQL running to completion and returning an error code
  which can indicate a policy violation.
  
  6. Added RDBM connection pooling. Once an operation is finished the
  connection to the RDBM is returned to a pool rather than closing.
  Allows the next operation to skip the initialization and authentication
  phases of contacting the RDBM. Also, if licensing with ODBC places
  a limit on the number of connections, an LDAP thread can block waiting
  for another thread to finish, so that no LDAP errors are returned
  for having more LDAP connections than allowed RDBM connections. An
  RDBM connection which receives an SQL error is marked as "tainted"
  so that it will be closed rather than returned to the pool.
    Also, RDBM connections must be bound to a given LDAP connection AND
  operation number, and NOT just the connection number.  Asynchronous
  LDAP clients can have multiple simultaneous LDAP operations which
  should not share the same RDBM connection.  A given LDAP operation can
  even make multiple SQL operations (e.g. a BIND operation which
  requires SASL to perform an LDAP search to convert the SASL ID to an
  LDAP DN), so each RDBM connection now has a refcount that must reach
  zero before the connection is returned to the free pool.
  
  7. Added ability to change the objectClass of an object. Required 
  considerable work to copy all attributes out of old object and into
  new object.  Does a schema check before proceeding.  Creates a new
  object, fills it in, deletes the old object, then changes the 
  oc_map_id and keyval of the entry in the "ldap_entries" table.
  
  8.  Generic fixes. Includes initializing pointers before they
  get used in error branch cases, pointer checks before dereferencing,
  resetting a return code to success after a COMPARE op, sealing
  memory leaks, and in search.c, changing some of the "1=1" tests to
  "2=2", "3=3", etc so that when reading slapd trace output, the 
  location in the source code where the x=x test was added to the SQL
  can be easily distinguished.
   */
  
  #ifndef __BACKSQL_H__
  #define __BACKSQL_H__
  
  /* former sql-types.h */
  #include <sql.h>
  #include <sqlext.h>
  
  typedef struct {
  	SWORD		ncols;
  	BerVarray	col_names;
  	UDWORD		*col_prec;
  	SQLSMALLINT	*col_type;
  	char		**cols;
  	SQLLEN		*value_len;
  } BACKSQL_ROW_NTS;
  
  /*
   * Better use the standard length of 8192 (as of slap.h)?
   *
   * NOTE: must be consistent with definition in ldap_entries table
   */
  /* #define BACKSQL_MAX_DN_LEN	SLAP_LDAPDN_MAXLEN */
  #define BACKSQL_MAX_DN_LEN	255
  
  /*
   * define to enable very extensive trace logging (debug only)
   */
  #undef BACKSQL_TRACE
  
  /*
   * define if using MS SQL and workaround needed (see sql-wrap.c)
   */
  #undef BACKSQL_MSSQL_WORKAROUND
  
  /*
   * define to enable values counting for attributes
   */
  #define BACKSQL_COUNTQUERY
  
  /*
   * define to enable prettification/validation of values
   */
  #define BACKSQL_PRETTY_VALIDATE
  
  /*
   * define to enable varchars as unique keys in user tables
   *
   * by default integers are used (and recommended)
   * for performances.  Integers are used anyway in back-sql
   * related tables.
   */
  #undef BACKSQL_ARBITRARY_KEY
  
  /*
   * type used for keys
   */
  #if defined(HAVE_LONG_LONG) && defined(SQL_C_UBIGINT) && \
  	( defined(HAVE_STRTOULL) || defined(HAVE_STRTOUQ) )
  typedef unsigned long long backsql_key_t;
  #define BACKSQL_C_NUMID	SQL_C_UBIGINT
  #define BACKSQL_IDNUMFMT "%llu"
  #define BACKSQL_STR2ID lutil_atoullx
  #else /* ! HAVE_LONG_LONG || ! SQL_C_UBIGINT */
  typedef unsigned long backsql_key_t;
  #define BACKSQL_C_NUMID	SQL_C_ULONG
  #define BACKSQL_IDNUMFMT "%lu"
  #define BACKSQL_STR2ID lutil_atoulx
  #endif /* ! HAVE_LONG_LONG */
  
  /*
   * define to enable support for syncprov overlay
   */
  #define BACKSQL_SYNCPROV
  
  /*
   * define to the appropriate aliasing string
   *
   * some RDBMSes tolerate (or require) that " AS " is not used
   * when aliasing tables/columns
   */
  #define BACKSQL_ALIASING	"AS "
  /* #define	BACKSQL_ALIASING	"" */
  
  /*
   * define to the appropriate quoting char
   *
   * some RDBMSes tolerate/require that the aliases be enclosed
   * in quotes.  This is especially true for those that do not
   * allow keywords used as aliases.
   */
  #define BACKSQL_ALIASING_QUOTE	""
  /* #define BACKSQL_ALIASING_QUOTE	"\"" */
  /* #define BACKSQL_ALIASING_QUOTE	"'" */
  
  /*
   * API
   *
   * a simple mechanism to allow DN mucking between the LDAP
   * and the stored string representation.
   */
  typedef struct backsql_api {
  	char			*ba_name;
  	int 			(*ba_config)( struct backsql_api *self, int argc, char *argv[] );
  	int			(*ba_destroy)( struct backsql_api *self );
  
  	int 			(*ba_dn2odbc)( Operation *op, SlapReply *rs, struct berval *dn );
  	int 			(*ba_odbc2dn)( Operation *op, SlapReply *rs, struct berval *dn );
  
  	void			*ba_private;
  	struct backsql_api	*ba_next;
  	char **ba_argv;
  	int	ba_argc;
  } backsql_api;
  
  /*
   * "structural" objectClass mapping structure
   */
  typedef struct backsql_oc_map_rec {
  	/*
  	 * Structure of corresponding LDAP objectClass definition
  	 */
  	ObjectClass		*bom_oc;
  #define BACKSQL_OC_NAME(ocmap)	((ocmap)->bom_oc->soc_cname.bv_val)
  	
  	struct berval		bom_keytbl;
  	struct berval		bom_keycol;
  	/* expected to return keyval of newly created entry */
  	char			*bom_create_proc;
  	/* in case create_proc does not return the keyval of the newly
  	 * created row */
  	char			*bom_create_keyval;
  	/* supposed to expect keyval as parameter and delete 
  	 * all the attributes as well */
  	char			*bom_delete_proc;
  	/* flags whether delete_proc is a function (whether back-sql 
  	 * should bind first parameter as output for return code) */
  	int			bom_expect_return;
  	backsql_key_t		bom_id;
  	Avlnode			*bom_attrs;
  	AttributeDescription	*bom_create_hint;
  } backsql_oc_map_rec;
  
  /*
   * attributeType mapping structure
   */
  typedef struct backsql_at_map_rec {
  	/* Description of corresponding LDAP attribute type */
  	AttributeDescription	*bam_ad;
  	AttributeDescription	*bam_true_ad;
  	/* ObjectClass if bam_ad is objectClass */
  	ObjectClass		*bam_oc;
  
  	struct berval	bam_from_tbls;
  	struct berval	bam_join_where;
  	struct berval	bam_sel_expr;
  
  	/* TimesTen, or, if a uppercase function is defined,
  	 * an uppercased version of bam_sel_expr */
  	struct berval	bam_sel_expr_u;
  
  	/* supposed to expect 2 binded values: entry keyval 
  	 * and attr. value to add, like "add_name(?,?,?)" */
  	char		*bam_add_proc;
  	/* supposed to expect 2 binded values: entry keyval 
  	 * and attr. value to delete */
  	char		*bam_delete_proc;
  	/* for optimization purposes attribute load query 
  	 * is preconstructed from parts on schemamap load time */
  	char		*bam_query;
  #ifdef BACKSQL_COUNTQUERY
  	char		*bam_countquery;
  #endif /* BACKSQL_COUNTQUERY */
  	/* following flags are bitmasks (first bit used for add_proc, 
  	 * second - for delete_proc) */
  	/* order of parameters for procedures above; 
  	 * 1 means "data then keyval", 0 means "keyval then data" */
  	int 		bam_param_order;
  	/* flags whether one or more of procedures is a function 
  	 * (whether back-sql should bind first parameter as output 
  	 * for return code) */
  	int 		bam_expect_return;
  
  	/* next mapping for attribute */
  	struct backsql_at_map_rec	*bam_next;
  } backsql_at_map_rec;
  
  #define BACKSQL_AT_MAP_REC_INIT { NULL, NULL, BER_BVC(""), BER_BVC(""), BER_BVNULL, BER_BVNULL, NULL, NULL, NULL, 0, 0, NULL }
  
  /* define to uppercase filters only if the matching rule requires it
   * (currently broken) */
  /* #define	BACKSQL_UPPERCASE_FILTER */
  
  #define	BACKSQL_AT_CANUPPERCASE(at)	( !BER_BVISNULL( &(at)->bam_sel_expr_u ) )
  
  /* defines to support bitmasks above */
  #define BACKSQL_ADD	0x1
  #define BACKSQL_DEL	0x2
  
  #define BACKSQL_IS_ADD(x)	( ( BACKSQL_ADD & (x) ) == BACKSQL_ADD )
  #define BACKSQL_IS_DEL(x)	( ( BACKSQL_DEL & (x) ) == BACKSQL_DEL )
  
  #define BACKSQL_NCMP(v1,v2)	ber_bvcmp((v1),(v2))
  
  #define BACKSQL_CONCAT
  /*
   * berbuf structure: a berval with a buffer size associated
   */
  typedef struct berbuf {
  	struct berval	bb_val;
  	ber_len_t	bb_len;
  } BerBuffer;
  
  #define BB_NULL		{ BER_BVNULL, 0 }
  
  /*
   * Entry ID structure
   */
  typedef struct backsql_entryID {
  	/* #define BACKSQL_ARBITRARY_KEY to allow a non-numeric key.
  	 * It is required by some special applications that use
  	 * strings as keys for the main table.
  	 * In this case, #define BACKSQL_MAX_KEY_LEN consistently
  	 * with the key size definition */
  #ifdef BACKSQL_ARBITRARY_KEY
  	struct berval		eid_id;
  	struct berval		eid_keyval;
  #define BACKSQL_MAX_KEY_LEN	64
  #else /* ! BACKSQL_ARBITRARY_KEY */
  	/* The original numeric key is maintained as default. */
  	backsql_key_t		eid_id;
  	backsql_key_t		eid_keyval;
  #endif /* ! BACKSQL_ARBITRARY_KEY */
  
  	backsql_key_t		eid_oc_id;
  	backsql_oc_map_rec	*eid_oc;
  	struct berval		eid_dn;
  	struct berval		eid_ndn;
  	struct backsql_entryID	*eid_next;
  } backsql_entryID;
  
  #ifdef BACKSQL_ARBITRARY_KEY
  #define BACKSQL_ENTRYID_INIT { BER_BVNULL, BER_BVNULL, 0, NULL, BER_BVNULL, BER_BVNULL, NULL }
  #else /* ! BACKSQL_ARBITRARY_KEY */
  #define BACKSQL_ENTRYID_INIT { 0, 0, 0, NULL, BER_BVNULL, BER_BVNULL, NULL }
  #endif /* BACKSQL_ARBITRARY_KEY */
  
  /* the function must collect the entry associated to nbase */
  #define BACKSQL_ISF_GET_ID	0x1U
  #define BACKSQL_ISF_GET_ENTRY	( 0x2U | BACKSQL_ISF_GET_ID )
  #define BACKSQL_ISF_GET_OC	( 0x4U | BACKSQL_ISF_GET_ID )
  #define BACKSQL_ISF_MATCHED	0x8U
  #define BACKSQL_IS_GET_ID(f) \
  	( ( (f) & BACKSQL_ISF_GET_ID ) == BACKSQL_ISF_GET_ID )
  #define BACKSQL_IS_GET_ENTRY(f) \
  	( ( (f) & BACKSQL_ISF_GET_ENTRY ) == BACKSQL_ISF_GET_ENTRY )
  #define BACKSQL_IS_GET_OC(f) \
  	( ( (f) & BACKSQL_ISF_GET_OC ) == BACKSQL_ISF_GET_OC )
  #define BACKSQL_IS_MATCHED(f) \
  	( ( (f) & BACKSQL_ISF_MATCHED ) == BACKSQL_ISF_MATCHED )
  typedef struct backsql_srch_info {
  	Operation		*bsi_op;
  	SlapReply		*bsi_rs;
  
  	unsigned		bsi_flags;
  #define	BSQL_SF_NONE			0x0000U
  #define	BSQL_SF_ALL_USER		0x0001U
  #define	BSQL_SF_ALL_OPER		0x0002U
  #define	BSQL_SF_ALL_ATTRS		(BSQL_SF_ALL_USER|BSQL_SF_ALL_OPER)
  #define BSQL_SF_FILTER_HASSUBORDINATE	0x0010U
  #define BSQL_SF_FILTER_ENTRYUUID	0x0020U
  #define BSQL_SF_FILTER_ENTRYCSN		0x0040U
  #define BSQL_SF_RETURN_ENTRYUUID	(BSQL_SF_FILTER_ENTRYUUID << 8)
  #define	BSQL_ISF(bsi, f)		( ( (bsi)->bsi_flags & f ) == f )
  #define	BSQL_ISF_ALL_USER(bsi)		BSQL_ISF(bsi, BSQL_SF_ALL_USER)
  #define	BSQL_ISF_ALL_OPER(bsi)		BSQL_ISF(bsi, BSQL_SF_ALL_OPER)
  #define	BSQL_ISF_ALL_ATTRS(bsi)		BSQL_ISF(bsi, BSQL_SF_ALL_ATTRS)
  
  	struct berval		*bsi_base_ndn;
  	int			bsi_use_subtree_shortcut;
  	backsql_entryID		bsi_base_id;
  	int			bsi_scope;
  /* BACKSQL_SCOPE_BASE_LIKE can be set by API in ors_scope
   * whenever the search base DN contains chars that cannot
   * be mapped into the charset used in the RDBMS; so they're
   * turned into '%' and an approximate ('LIKE') condition
   * is used */
  #define BACKSQL_SCOPE_BASE_LIKE		( LDAP_SCOPE_BASE | 0x1000 )
  	Filter			*bsi_filter;
  	time_t			bsi_stoptime;
  
  	backsql_entryID		*bsi_id_list,
  				**bsi_id_listtail,
  				*bsi_c_eid;
  	int			bsi_n_candidates;
  	int			bsi_status;
  
  	backsql_oc_map_rec	*bsi_oc;
  	struct berbuf		bsi_sel,
  				bsi_from,
  				bsi_join_where,
  				bsi_flt_where;
  	ObjectClass		*bsi_filter_oc;
  	SQLHDBC			bsi_dbh;
  	AttributeName		*bsi_attrs;
  
  	Entry			*bsi_e;
  } backsql_srch_info;
  
  /*
   * Backend private data structure
   */
  typedef struct backsql_info {
  	char		*sql_dbhost;
  	int		sql_dbport;
  	char		*sql_dbuser;
  	char		*sql_dbpasswd;
  	char		*sql_dbname;
  
   	/*
  	 * SQL condition for subtree searches differs in syntax:
  	 * "LIKE CONCAT('%',?)" or "LIKE '%'+?" or "LIKE '%'||?"
  	 * or smtg else 
  	 */
  	struct berval	sql_subtree_cond;
  	struct berval	sql_children_cond;
  	struct berval	sql_dn_match_cond;
  	char		*sql_oc_query;
  	char		*sql_at_query;
  	char		*sql_insentry_stmt;
  	char		*sql_delentry_stmt;
  	char		*sql_renentry_stmt;
  	char		*sql_delobjclasses_stmt;
  	char		*sql_id_query;
  	char		*sql_has_children_query;
  	char		*sql_list_children_query;
  
  	MatchingRule	*sql_caseIgnoreMatch;
  	MatchingRule	*sql_telephoneNumberMatch;
  
  	struct berval	sql_upper_func;
  	struct berval	sql_upper_func_open;
  	struct berval	sql_upper_func_close;
  	struct berval	sql_strcast_func;
  	BerVarray	sql_concat_func;
  	char		*sql_concat_patt;
  
  	struct berval	sql_aliasing;
  	struct berval	sql_aliasing_quote;
  	struct berval	sql_dn_oc_aliasing;
  
  	AttributeName	*sql_anlist;
  
  	unsigned int	sql_flags;
  #define	BSQLF_SCHEMA_LOADED		0x0001
  #define	BSQLF_UPPER_NEEDS_CAST		0x0002
  #define	BSQLF_CREATE_NEEDS_SELECT	0x0004
  #define	BSQLF_FAIL_IF_NO_MAPPING	0x0008
  #define BSQLF_HAS_LDAPINFO_DN_RU	0x0010
  #define BSQLF_DONTCHECK_LDAPINFO_DN_RU	0x0020
  #define BSQLF_USE_REVERSE_DN		0x0040
  #define BSQLF_ALLOW_ORPHANS		0x0080
  #define BSQLF_USE_SUBTREE_SHORTCUT	0x0100
  #define BSQLF_FETCH_ALL_USERATTRS	0x0200
  #define BSQLF_FETCH_ALL_OPATTRS		0x0400
  #define	BSQLF_FETCH_ALL_ATTRS		(BSQLF_FETCH_ALL_USERATTRS|BSQLF_FETCH_ALL_OPATTRS)
  #define BSQLF_CHECK_SCHEMA		0x0800
  #define BSQLF_AUTOCOMMIT_ON		0x1000
  
  #define BACKSQL_ISF(si, f) \
  	(((si)->sql_flags & f) == f)
  
  #define	BACKSQL_SCHEMA_LOADED(si) \
  	BACKSQL_ISF(si, BSQLF_SCHEMA_LOADED)
  #define BACKSQL_UPPER_NEEDS_CAST(si) \
  	BACKSQL_ISF(si, BSQLF_UPPER_NEEDS_CAST)
  #define BACKSQL_CREATE_NEEDS_SELECT(si) \
  	BACKSQL_ISF(si, BSQLF_CREATE_NEEDS_SELECT)
  #define BACKSQL_FAIL_IF_NO_MAPPING(si) \
  	BACKSQL_ISF(si, BSQLF_FAIL_IF_NO_MAPPING)
  #define BACKSQL_HAS_LDAPINFO_DN_RU(si) \
  	BACKSQL_ISF(si, BSQLF_HAS_LDAPINFO_DN_RU)
  #define BACKSQL_DONTCHECK_LDAPINFO_DN_RU(si) \
  	BACKSQL_ISF(si, BSQLF_DONTCHECK_LDAPINFO_DN_RU)
  #define BACKSQL_USE_REVERSE_DN(si) \
  	BACKSQL_ISF(si, BSQLF_USE_REVERSE_DN)
  #define BACKSQL_CANUPPERCASE(si) \
  	(!BER_BVISNULL( &(si)->sql_upper_func ))
  #define BACKSQL_ALLOW_ORPHANS(si) \
  	BACKSQL_ISF(si, BSQLF_ALLOW_ORPHANS)
  #define BACKSQL_USE_SUBTREE_SHORTCUT(si) \
  	BACKSQL_ISF(si, BSQLF_USE_SUBTREE_SHORTCUT)
  #define BACKSQL_FETCH_ALL_USERATTRS(si) \
  	BACKSQL_ISF(si, BSQLF_FETCH_ALL_USERATTRS)
  #define BACKSQL_FETCH_ALL_OPATTRS(si) \
  	BACKSQL_ISF(si, BSQLF_FETCH_ALL_OPATTRS)
  #define BACKSQL_FETCH_ALL_ATTRS(si) \
  	BACKSQL_ISF(si, BSQLF_FETCH_ALL_ATTRS)
  #define BACKSQL_CHECK_SCHEMA(si) \
  	BACKSQL_ISF(si, BSQLF_CHECK_SCHEMA)
  #define BACKSQL_AUTOCOMMIT_ON(si) \
  	BACKSQL_ISF(si, BSQLF_AUTOCOMMIT_ON)
  
  	Entry		*sql_baseObject;
  	char		*sql_base_ob_file;
  #ifdef BACKSQL_ARBITRARY_KEY
  #define BACKSQL_BASEOBJECT_IDSTR	"baseObject"
  #define BACKSQL_BASEOBJECT_KEYVAL	BACKSQL_BASEOBJECT_IDSTR
  #define	BACKSQL_IS_BASEOBJECT_ID(id)	(bvmatch((id), &backsql_baseObject_bv))
  #else /* ! BACKSQL_ARBITRARY_KEY */
  #define BACKSQL_BASEOBJECT_ID		0
  #define BACKSQL_BASEOBJECT_IDSTR	LDAP_XSTRING(BACKSQL_BASEOBJECT_ID)
  #define BACKSQL_BASEOBJECT_KEYVAL	0
  #define	BACKSQL_IS_BASEOBJECT_ID(id)	(*(id) == BACKSQL_BASEOBJECT_ID)
  #endif /* ! BACKSQL_ARBITRARY_KEY */
  #define BACKSQL_BASEOBJECT_OC		0
  	
  	Avlnode		*sql_db_conns;
  	SQLHDBC		sql_dbh;
  	ldap_pvt_thread_mutex_t		sql_dbconn_mutex;
  	Avlnode		*sql_oc_by_oc;
  	Avlnode		*sql_oc_by_id;
  	ldap_pvt_thread_mutex_t		sql_schema_mutex;
   	SQLHENV		sql_db_env;
  
  	backsql_api	*sql_api;
  } backsql_info;
  
  #define BACKSQL_SUCCESS( rc ) \
  	( (rc) == SQL_SUCCESS || (rc) == SQL_SUCCESS_WITH_INFO )
  
  #define BACKSQL_AVL_STOP		0
  #define BACKSQL_AVL_CONTINUE		1
  
  /* see ldap.h for the meaning of the macros and of the values */
  #define BACKSQL_LEGAL_ERROR( rc ) \
  	( LDAP_RANGE( (rc), 0x00, 0x0e ) \
  	  || LDAP_ATTR_ERROR( (rc) ) \
  	  || LDAP_NAME_ERROR( (rc) ) \
  	  || LDAP_SECURITY_ERROR( (rc) ) \
  	  || LDAP_SERVICE_ERROR( (rc) ) \
  	  || LDAP_UPDATE_ERROR( (rc) ) )
  #define BACKSQL_SANITIZE_ERROR( rc ) \
  	( BACKSQL_LEGAL_ERROR( (rc) ) ? (rc) : LDAP_OTHER )
  
  #define BACKSQL_IS_BINARY(ct) \
  	( (ct) == SQL_BINARY \
  	  || (ct) == SQL_VARBINARY \
  	  || (ct) == SQL_LONGVARBINARY)
  
  #ifdef BACKSQL_ARBITRARY_KEY
  #define BACKSQL_IDFMT "%s"
  #define BACKSQL_IDARG(arg) ((arg).bv_val)
  #else /* ! BACKSQL_ARBITRARY_KEY */
  #define BACKSQL_IDFMT BACKSQL_IDNUMFMT
  #define BACKSQL_IDARG(arg) (arg)
  #endif /* ! BACKSQL_ARBITRARY_KEY */
  
  #endif /* __BACKSQL_H__ */
  
  