widgets/data_list/SQLDataListSource.inc

<?php
/**
 * This file holds the DataListSource child that can
 * handle working with SQL databases.
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @package phpHtmlLib
 */

/**
 * We require the DataListSource
 */
require_once($phphtmllib."/widgets/data_list/DataListSource.inc");

/**
 * 
 */
class SQLDataListSource extends DataListSource {

        /**
         * this holds all of the options
         * that make up the sql query
         *
         */
        var $_db_options = array("values" => "",
                                                         "tables" => "",
                                                         "where_clause" => "",
                                                         "groupby_clause" => "",
                                                         "count_column" => "*");

        /**
         * The entire query built by
         * build_query()
         */
        var $_query = "";


    /**
     * The flag that tells us to use
     * case sensitive order by as a default.
     * 
     * NOTE: we are case sensitive by default
     * 
     */
    var $_default_order_sensitivity = TRUE;


    /**
     * Set which DB options
     * to use for this list.
     *
     * @param string - $values - the values you
     *                           want to select
     *                           from the db table(s)
     * @param string - $tables - The tables you want
     *                           to select on.
     * @param string - $where_clause - portion of the where
     *                                 clause.
     *                                 This expects name=value
     *                                 pairs only.
     * @param string - $groupby_clause - the groupby portion of the
     *                                   query.  same format as where_clause
     *
     */
    function setup_db_options( $values, $tables, $where_clause='',
                               $groupby_clause='' ) {
        $this->set_db_values( $values );
        $this->set_db_tables( $tables );
        $this->set_db_where_clause( $where_clause );
        $this->set_db_groupby_clause( $groupby_clause );
    }

    /**
     * Set the values we want to select
     * from the db.
     *
     * @param string - $values
     */
    function set_db_values( $values ) {
        $this->_db_options["values"] = $values;
    }

        /**
         * This function returns the 
         * values we need to search for
         * in the sql query
         *
         * @return string
         */
        function get_db_values() {
                return $this->_db_options["values"];
        }

    /**
     * Set the tables from the DB you
     * want to select on.
     *
     * @param   string - $tables
     */
    function set_db_tables( $tables ) {
        $this->_db_options["tables"] = $tables;
    }

        /**
         * returns the table(s) used in the query
         *
         * @return string
         */
        function get_db_tables() {
                return $this->_db_options["tables"];
        }

    /**
     * Set the user portion of the where
     * clause.
     * @param string - name value pairs
     */
    function set_db_where_clause( $where_clause ) {
        $this->_db_options["where_clause"] = $where_clause;
    }

    /**
     * Sets the groupby clause for the query
     *
     * @param string name value pairs
     */
    function set_db_groupby_clause( $clause ) {
        $this->_db_options["groupby_clause"] = $clause;
    }

    /**
     * This function changes the counted column.
     * By default, we use count(1)
     * But sometime you need count(distinct KEY) for example
     *
     */
    function set_count_column($var) {
        $this->_db_options["count_column"] = $var;
    }

        /**
         * this returns the current count column
         *
         * @return string
         */
        function get_count_column() {
                return $this->_db_options["count_column"];
        }

    // This functions joins an arbitrary number of clauses using the
    // specified connector. It can be used in one of the following two
    // ways:
    //      join($connector, $clause_1, $clause_2, ...);
    //      join($connector, $clauses_array);
    //
    function join_clauses() {
        $num_args = func_num_args();
        $args = func_get_args();

        $connector = $args[0];
        $clauses = array();

        if (is_array($args[1])) {
            $arr = $args[1];
        } else {
            $arr = $args;
            array_shift($arr);
        }
        $count = sizeof($arr);

        for ($i = 0; $i < $count; ++$i) {
            if ($arr[$i]) {
                array_push($clauses, $arr[$i]);
            }
        }

        // Now the array "$clauses" contains all non null clauses.
        $num_clauses = sizeof($clauses);
        if ($num_clauses = 0) {
            return "";
        }
        return join(" $connector ", $clauses);
    }

    /**
     * this builds the search clause
     *
     * @return string
     */
    function simple_search_where_clause() {
        $search_field = $this->get_searchby();
        $search_value = $this->search_value_filter($this->get_searchby_value());

        if (($search_field == '') || ($search_value == ''))
            return '';

        $where_clause = "lower(".$search_field.")";

        //see if the simple search modifier is turned on
        //and then use it for the like clause
        if ($this->get_simplesearch_modifier()) {
            $search_value = strtolower($search_value);
            //its on.  lets see if it has a value.
            $modifier = $this->get_simplesearch_modifier();
            switch ($modifier) {
            case "BEGINS":
                $like_clause = " like '".$search_value."%' ";
                break;
            case "ENDS":
                $like_clause = " like '%".$search_value."' ";
                break;
            case "EXACT":
                $like_clause = " like '".$search_value."' ";
                break;

            case "CONTAINS":
            default:
                $like_clause = " like '%".$search_value."%' ";
                break;
            }
        }
        else {
            $like_clause = " like '%".$search_value."%'";
        }

                $where_clause .= $like_clause;
        return $where_clause;
    }

    /**
     * This function is responsible for
     * building the portion of the where clause
     * for doing an advanced search.
     * NOTE: the child class MUST override this
     *       method
     * @return string - portion of the where clause
     */
    function advanced_search_where_clause() {
        return "";
    }

    /**
     * This function does the variable cleaning
     * that is required to use a search value
     * in a sql query
     *
     * @param string - the origina string from the user
     * @return string - the "cleaned" string
     */
    function search_value_filter( $value ) {
        $value = $this->sql_varchar_filter( strip_tags(stripslashes(trim($value))) );
        $value = str_replace('%', '\%', $value);
        $value = str_replace('_', '\_', $value);
        return $value;
    }

        /**
         * Clean up the string so it can work in a db
         *
         * @param string
         * @return string
         */
        function sql_varchar_filter( $value ) {
                return str_replace("'","''",$value);
        }

    /**
     * This builds the where clause for
     * the query
     *
     * @return string the where clause.
     */
    function build_where_clause() {
        $where_clause = $this->_db_options["where_clause"];
        if ($where_clause) {
            $where_clause = "( $where_clause ) ";
        }

        $search_clause = $this->build_search_clause();
        if ($search_clause) {
            $search_clause = " ( $search_clause ) ";
        }

        $where_clause = trim($this->join_clauses("AND",
                                                 $where_clause,
                                                 $search_clause));
        if ($where_clause) {
            $where_clause = " WHERE $where_clause";
        }
        return $where_clause;
    }

    /**
     * This method builds the where clause.
     *
     * @return string
     */
    function build_search_clause() {
        if ($this->get_search_type() == "advanced") {
            return $this->advanced_search_where_clause();
        } else {
            return $this->simple_search_where_clause();
        }
    }

    /**
     * This function builds the orderby clause
     * for the DB query.
     *
     * @param string - DB table field to order by
     * @param string - order assension value.
     * @param boolean - case insensitive sort?
     *
     * @return string.
     */
    function setup_order($orderby, $reverseorder, $icase_sort=FALSE) {
        if ($icase_sort) {
            $orderby = "lower(".$orderby.")";
        }

        $secondary = $this->get_secondary_orderby();

        if (count($secondary) > 0) {
            $orderby .= ",".implode(",", $secondary);
        }

        if ($reverseorder == "true") {
            return "order by ".$orderby." DESC";
        }
        else {
            return "order by ".$orderby." ASC";
        }
    }

    /**
     * This builds the db query ORDER BY
     * clause used to sort the data from the DB.
     *
     * @return string - the order by clause
     */
    function build_order_clause() {

        //Set up reverseorder correctly
        $icase_sort = !$this->get_default_order_case_sensitive();
        $orderby = $this->get_orderby();
        foreach( $this->_columns as $col_name => $data ) {
            if (($data["data_name"] == $orderby) &&
                ($data["reverseorder"] == "true") && 
                                !isset( ${$this->reverseorderVar})) {
                $this->set_reverseorder( $data["reverseorder"] );
            }
            if ($data["data_name"] == $orderby && 
                $data["sortable"] == SORTABLE_ICASE) {
                $icase_sort = TRUE;
            } else {
                $icase_sort = FALSE;
            }
        }

        $orderClause = $this->setup_order($orderby, 
                                          $this->get_reverseorder(),
                                          $icase_sort );
        return $orderClause;
    }

    /**
     * this builds the groupby clause of the query
     *
     * @return string
     */
    function build_groupby_clause() {
        $groupby = $this->_db_options["groupby_clause"];
        if ($groupby) {
            $groupby = " GROUP BY $groupby ";
        }

        return $groupby;
    }

    /**
     * build the entire DB query
     *
     * @param boolean - build the limit clause or not/
     * @return string - the full query string to the DB.
     */
    function build_query($limit_flag=TRUE) {

        $where_clause = $this->build_where_clause();
        $order_clause = $this->build_order_clause();
        $groupby_clause = $this->build_groupby_clause();
                if ($limit_flag) {
                        $limit_clause = $this->build_limit_clause($this->get_offset(), $this->get_limit());
                }

        $query = "select ".$this->get_db_values()." from ".$this->get_db_tables()." " .
                 $where_clause." ".$groupby_clause." ".$order_clause .
                             " ".$limit_clause;

        return $query;
    }


        function do_prequery() {
                //ok now count the total # of rows so
        //we can calculate the # of pages.
                //count rows
        //ok now count the total # of rows so 
        //we can calculate the # of pages.
                $this->set_total_rows( $this->count( $this->get_db_tables(),
                                                                                         $this->build_where_clause(),
                                                                                         $this->get_count_column() ) );

                $this->_query = $this->build_query();
        }


        /************************************************/
        /*            DB Specific Routines              */
        /*          ------------------------            */
        /*  These must be extended by the child class   */
        /* This gives you the power to do the specific  */
        /* DB interactions as you see fit.  Some folks  */
        /* use the low level php db API's, some use the */
        /* PEAR db abstraction objects, and others roll */
        /* their own DB objects.  Extend the functions  */
        /* to provide:                                  */
        /*                                              */
        /* do_query() - this function's purpose is to   */
    /*              execute the sql query that is   */
        /*              available in $this->_query by   */
        /*              the time do_query() is called.  */
        /*                                              */
        /* get_next_data_row() - This function returns  */
        /*              an associative array of the     */
        /*              next row of data from the query.*/
        /*                                              */
        /* build_limit_clause() - This function builds  */
        /*              and returns the "limit clause"  */
        /*              portion of a sql query.  Each   */
        /*              DB implementation is different  */
        /*              on how it deals with limiting   */
        /*              the amount of data you want     */
        /*                              back from the query.  Oracle    */
        /*                              has no limit clause, so it has  */
        /*                              to do this in very tricky/nasty */
        /*                              ways.                                                   */
        /*                                              */
        /* count() - this function simply returns the   */
        /*           number of rows (to be) found in    */
        /*           sql query.                         */
        /*                                              */
        /************************************************/

    /**
     * Do the query to the DB and pull in all of
     * the records locally.
     *
     * @return boolean - the query passed/failed.
     */
    function do_query() {
                //execute the sql query.
                //we don't actually get the results of
                //the query here, when just execute it.
                user_error("SQLDataListSource::do_query() - Child must override");
        return false;
    }

        /**
         * This function gets the next data row
         * from the query()
         *
         * @return array()
         */
        function get_next_data_row() {
           user_error("SQLDataListSource::get_next_data_row() - Child must override");
       return array();
        }       

    /**
     * This function builds the limit
     * clause portion of a DB query.
         * This is specific to the particular
         * DB implementation.  
     *
     * @return string - the limit portion of 
     *                  the query.
     */
    function build_limit_clause($offset, $limit) {
                user_error("SQLDataListSource::build_limit_clause() - Child must override");
    }

    /**
     * find the number of rows to be returned 
     * from a query from a table and where clause
     *
     * @param string $table - the table to count from
     * @param string $where_clause - a where clause
     *
     * @return int the # of rows
     */
    function count($tables, $where_clause='', $count_clause='*') {
                user_error("SQLDataListSource::count() - Child must override");
    }

    /**
     * This function is used to set the flag for the
     * ability to sort/order by case sensitive or not.
     * 
     * @param boolean - TRUE = case sensitive by default
     * @return none
     */
    function set_default_order_case_sensitive($flag=TRUE) {
        $this->_default_order_sensitivity = $flag;
    }

    /**
     * This function is used to get the flag for the
     * ability to sort/order by case sensitive or not.
     * 
     * @param boolean - TRUE = case sensitive by default
     * @return none
     */
    function get_default_order_case_sensitive() {
        return $this->_default_order_sensitivity;
    }
}

?>
1	<?php
2	/**
3	* This file holds the DataListSource child that can
4	* handle working with SQL databases.
5	*
6	* @author Walter A. Boring IV <waboring@buildabetterweb.com>
7	* @package phpHtmlLib
8	*/
9
10	/**
11	* We require the DataListSource
12	*/
13	require_once($phphtmllib."/widgets/data_list/DataListSource.inc");
14
15	/**
16	*
17	*/
18	class SQLDataListSource extends DataListSource {
19
20	/**
21	* this holds all of the options
22	* that make up the sql query
23	*
24	*/
25	var $_db_options = array("values" => "",
26	"tables" => "",
27	"where_clause" => "",
28	"groupby_clause" => "",
29	"count_column" => "*");
30
31	/**
32	* The entire query built by
33	* build_query()
34	*/
35	var $_query = "";
36
37
38	/**
39	* The flag that tells us to use
40	* case sensitive order by as a default.
41	*
42	* NOTE: we are case sensitive by default
43	*
44	*/
45	var $_default_order_sensitivity = TRUE;
46
47
48	/**
49	* Set which DB options
50	* to use for this list.
51	*
52	* @param string - $values - the values you
53	* want to select
54	* from the db table(s)
55	* @param string - $tables - The tables you want
56	* to select on.
57	* @param string - $where_clause - portion of the where
58	* clause.
59	* This expects name=value
60	* pairs only.
61	* @param string - $groupby_clause - the groupby portion of the
62	* query. same format as where_clause
63	*
64	*/
65	function setup_db_options( $values, $tables, $where_clause='',
66	$groupby_clause='' ) {
67	$this->set_db_values( $values );
68	$this->set_db_tables( $tables );
69	$this->set_db_where_clause( $where_clause );
70	$this->set_db_groupby_clause( $groupby_clause );
71	}
72
73	/**
74	* Set the values we want to select
75	* from the db.
76	*
77	* @param string - $values
78	*/
79	function set_db_values( $values ) {
80	$this->_db_options["values"] = $values;
81	}
82
83	/**
84	* This function returns the
85	* values we need to search for
86	* in the sql query
87	*
88	* @return string
89	*/
90	function get_db_values() {
91	return $this->_db_options["values"];
92	}
93
94	/**
95	* Set the tables from the DB you
96	* want to select on.
97	*
98	* @param string - $tables
99	*/
100	function set_db_tables( $tables ) {
101	$this->_db_options["tables"] = $tables;
102	}
103
104	/**
105	* returns the table(s) used in the query
106	*
107	* @return string
108	*/
109	function get_db_tables() {
110	return $this->_db_options["tables"];
111	}
112
113	/**
114	* Set the user portion of the where
115	* clause.
116	* @param string - name value pairs
117	*/
118	function set_db_where_clause( $where_clause ) {
119	$this->_db_options["where_clause"] = $where_clause;
120	}
121
122	/**
123	* Sets the groupby clause for the query
124	*
125	* @param string name value pairs
126	*/
127	function set_db_groupby_clause( $clause ) {
128	$this->_db_options["groupby_clause"] = $clause;
129	}
130
131	/**
132	* This function changes the counted column.
133	* By default, we use count(1)
134	* But sometime you need count(distinct KEY) for example
135	*
136	*/
137	function set_count_column($var) {
138	$this->_db_options["count_column"] = $var;
139	}
140
141	/**
142	* this returns the current count column
143	*
144	* @return string
145	*/
146	function get_count_column() {
147	return $this->_db_options["count_column"];
148	}
149
150	// This functions joins an arbitrary number of clauses using the
151	// specified connector. It can be used in one of the following two
152	// ways:
153	// join($connector, $clause_1, $clause_2, ...);
154	// join($connector, $clauses_array);
155	//
156	function join_clauses() {
157	$num_args = func_num_args();
158	$args = func_get_args();
159
160	$connector = $args[0];
161	$clauses = array();
162
163	if (is_array($args[1])) {
164	$arr = $args[1];
165	} else {
166	$arr = $args;
167	array_shift($arr);
168	}
169	$count = sizeof($arr);
170
171	for ($i = 0; $i < $count; ++$i) {
172	if ($arr[$i]) {
173	array_push($clauses, $arr[$i]);
174	}
175	}
176
177	// Now the array "$clauses" contains all non null clauses.
178	$num_clauses = sizeof($clauses);
179	if ($num_clauses = 0) {
180	return "";
181	}
182	return join(" $connector ", $clauses);
183	}
184
185	/**
186	* this builds the search clause
187	*
188	* @return string
189	*/
190	function simple_search_where_clause() {
191	$search_field = $this->get_searchby();
192	$search_value = $this->search_value_filter($this->get_searchby_value());
193
194	if (($search_field == '') \|\| ($search_value == ''))
195	return '';
196
197	$where_clause = "lower(".$search_field.")";
198
199	//see if the simple search modifier is turned on
200	//and then use it for the like clause
201	if ($this->get_simplesearch_modifier()) {
202	$search_value = strtolower($search_value);
203	//its on. lets see if it has a value.
204	$modifier = $this->get_simplesearch_modifier();
205	switch ($modifier) {
206	case "BEGINS":
207	$like_clause = " like '".$search_value."%' ";
208	break;
209	case "ENDS":
210	$like_clause = " like '%".$search_value."' ";
211	break;
212	case "EXACT":
213	$like_clause = " like '".$search_value."' ";
214	break;
215
216	case "CONTAINS":
217	default:
218	$like_clause = " like '%".$search_value."%' ";
219	break;
220	}
221	}
222	else {
223	$like_clause = " like '%".$search_value."%'";
224	}
225
226	$where_clause .= $like_clause;
227	return $where_clause;
228	}
229
230	/**
231	* This function is responsible for
232	* building the portion of the where clause
233	* for doing an advanced search.
234	* NOTE: the child class MUST override this
235	* method
236	* @return string - portion of the where clause
237	*/
238	function advanced_search_where_clause() {
239	return "";
240	}
241
242	/**
243	* This function does the variable cleaning
244	* that is required to use a search value
245	* in a sql query
246	*
247	* @param string - the origina string from the user
248	* @return string - the "cleaned" string
249	*/
250	function search_value_filter( $value ) {
251	$value = $this->sql_varchar_filter( strip_tags(stripslashes(trim($value))) );
252	$value = str_replace('%', '\%', $value);
253	$value = str_replace('_', '\_', $value);
254	return $value;
255	}
256
257	/**
258	* Clean up the string so it can work in a db
259	*
260	* @param string
261	* @return string
262	*/
263	function sql_varchar_filter( $value ) {
264	return str_replace("'","''",$value);
265	}
266
267	/**
268	* This builds the where clause for
269	* the query
270	*
271	* @return string the where clause.
272	*/
273	function build_where_clause() {
274	$where_clause = $this->_db_options["where_clause"];
275	if ($where_clause) {
276	$where_clause = "( $where_clause ) ";
277	}
278
279	$search_clause = $this->build_search_clause();
280	if ($search_clause) {
281	$search_clause = " ( $search_clause ) ";
282	}
283
284	$where_clause = trim($this->join_clauses("AND",
285	$where_clause,
286	$search_clause));
287	if ($where_clause) {
288	$where_clause = " WHERE $where_clause";
289	}
290	return $where_clause;
291	}
292
293	/**
294	* This method builds the where clause.
295	*
296	* @return string
297	*/
298	function build_search_clause() {
299	if ($this->get_search_type() == "advanced") {
300	return $this->advanced_search_where_clause();
301	} else {
302	return $this->simple_search_where_clause();
303	}
304	}
305
306	/**
307	* This function builds the orderby clause
308	* for the DB query.
309	*
310	* @param string - DB table field to order by
311	* @param string - order assension value.
312	* @param boolean - case insensitive sort?
313	*
314	* @return string.
315	*/
316	function setup_order($orderby, $reverseorder, $icase_sort=FALSE) {
317	if ($icase_sort) {
318	$orderby = "lower(".$orderby.")";
319	}
320
321	$secondary = $this->get_secondary_orderby();
322
323	if (count($secondary) > 0) {
324	$orderby .= ",".implode(",", $secondary);
325	}
326
327	if ($reverseorder == "true") {
328	return "order by ".$orderby." DESC";
329	}
330	else {
331	return "order by ".$orderby." ASC";
332	}
333	}
334
335	/**
336	* This builds the db query ORDER BY
337	* clause used to sort the data from the DB.
338	*
339	* @return string - the order by clause
340	*/
341	function build_order_clause() {
342
343	//Set up reverseorder correctly
344	$icase_sort = !$this->get_default_order_case_sensitive();
345	$orderby = $this->get_orderby();
346	foreach( $this->_columns as $col_name => $data ) {
347	if (($data["data_name"] == $orderby) &&
348	($data["reverseorder"] == "true") &&
349	!isset( ${$this->reverseorderVar})) {
350	$this->set_reverseorder( $data["reverseorder"] );
351	}
352	if ($data["data_name"] == $orderby &&
353	$data["sortable"] == SORTABLE_ICASE) {
354	$icase_sort = TRUE;
355	} else {
356	$icase_sort = FALSE;
357	}
358	}
359
360	$orderClause = $this->setup_order($orderby,
361	$this->get_reverseorder(),
362	$icase_sort );
363	return $orderClause;
364	}
365
366	/**
367	* this builds the groupby clause of the query
368	*
369	* @return string
370	*/
371	function build_groupby_clause() {
372	$groupby = $this->_db_options["groupby_clause"];
373	if ($groupby) {
374	$groupby = " GROUP BY $groupby ";
375	}
376
377	return $groupby;
378	}
379
380	/**
381	* build the entire DB query
382	*
383	* @param boolean - build the limit clause or not/
384	* @return string - the full query string to the DB.
385	*/
386	function build_query($limit_flag=TRUE) {
387
388	$where_clause = $this->build_where_clause();
389	$order_clause = $this->build_order_clause();
390	$groupby_clause = $this->build_groupby_clause();
391	if ($limit_flag) {
392	$limit_clause = $this->build_limit_clause($this->get_offset(), $this->get_limit());
393	}
394
395	$query = "select ".$this->get_db_values()." from ".$this->get_db_tables()." " .
396	$where_clause." ".$groupby_clause." ".$order_clause .
397	" ".$limit_clause;
398
399	return $query;
400	}
401
402
403	function do_prequery() {
404	//ok now count the total # of rows so
405	//we can calculate the # of pages.
406	//count rows
407	//ok now count the total # of rows so
408	//we can calculate the # of pages.
409	$this->set_total_rows( $this->count( $this->get_db_tables(),
410	$this->build_where_clause(),
411	$this->get_count_column() ) );
412
413	$this->_query = $this->build_query();
414	}
415
416
417	/************************************************/
418	/* DB Specific Routines */
419	/* ------------------------ */
420	/* These must be extended by the child class */
421	/* This gives you the power to do the specific */
422	/* DB interactions as you see fit. Some folks */
423	/* use the low level php db API's, some use the */
424	/* PEAR db abstraction objects, and others roll */
425	/* their own DB objects. Extend the functions */
426	/* to provide: */
427	/* */
428	/* do_query() - this function's purpose is to */
429	/* execute the sql query that is */
430	/* available in $this->_query by */
431	/* the time do_query() is called. */
432	/* */
433	/* get_next_data_row() - This function returns */
434	/* an associative array of the */
435	/* next row of data from the query.*/
436	/* */
437	/* build_limit_clause() - This function builds */
438	/* and returns the "limit clause" */
439	/* portion of a sql query. Each */
440	/* DB implementation is different */
441	/* on how it deals with limiting */
442	/* the amount of data you want */
443	/* back from the query. Oracle */
444	/* has no limit clause, so it has */
445	/* to do this in very tricky/nasty */
446	/* ways. */
447	/* */
448	/* count() - this function simply returns the */
449	/* number of rows (to be) found in */
450	/* sql query. */
451	/* */
452	/************************************************/
453
454	/**
455	* Do the query to the DB and pull in all of
456	* the records locally.
457	*
458	* @return boolean - the query passed/failed.
459	*/
460	function do_query() {
461	//execute the sql query.
462	//we don't actually get the results of
463	//the query here, when just execute it.
464	user_error("SQLDataListSource::do_query() - Child must override");
465	return false;
466	}
467
468	/**
469	* This function gets the next data row
470	* from the query()
471	*
472	* @return array()
473	*/
474	function get_next_data_row() {
475	user_error("SQLDataListSource::get_next_data_row() - Child must override");
476	return array();
477	}
478
479	/**
480	* This function builds the limit
481	* clause portion of a DB query.
482	* This is specific to the particular
483	* DB implementation.
484	*
485	* @return string - the limit portion of
486	* the query.
487	*/
488	function build_limit_clause($offset, $limit) {
489	user_error("SQLDataListSource::build_limit_clause() - Child must override");
490	}
491
492	/**
493	* find the number of rows to be returned
494	* from a query from a table and where clause
495	*
496	* @param string $table - the table to count from
497	* @param string $where_clause - a where clause
498	*
499	* @return int the # of rows
500	*/
501	function count($tables, $where_clause='', $count_clause='*') {
502	user_error("SQLDataListSource::count() - Child must override");
503	}
504
505	/**
506	* This function is used to set the flag for the
507	* ability to sort/order by case sensitive or not.
508	*
509	* @param boolean - TRUE = case sensitive by default
510	* @return none
511	*/
512	function set_default_order_case_sensitive($flag=TRUE) {
513	$this->_default_order_sensitivity = $flag;
514	}
515
516	/**
517	* This function is used to get the flag for the
518	* ability to sort/order by case sensitive or not.
519	*
520	* @param boolean - TRUE = case sensitive by default
521	* @return none
522	*/
523	function get_default_order_case_sensitive() {
524	return $this->_default_order_sensitivity;
525	}
526	}
527
528	?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26