1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | http://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Authors: |
14 | Israel Ekpo <iekpo@php.net> |
15 | Omar Shaban <omars@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 #include "php_solr.h"
20
21 /* Outstanding Work/Changes */
22
23 /* TODO: Change SolrQuery::getTermsSort() to return integer */
24 /* TODO: Change SolrQuery::getFacetSort() to return integer */
25
26 /**
27 * Note about methods implementation:
28 *
29 * One reason why each SolrQuery has custom code is because each method
30 * could require separate tweaking.
31 *
32 * At this point in time, even though most of the SolrQuery methods share
33 * basic features, I still believe that is a better idea to write separate code
34 * for each method implementation.
35 *
36 * This will make the methods easier to maintain because
37 *
38 * from time to time, Solr modifies the way some of the request parameters are
39 * submitted or processed.
40 *
41 * Hence, it is currently more logical to make each method an independent entity.
42 */
43
44 /* {{{ proto SolrQuery::__construct([string q])
45 Constructor for SolrQuery */
PHP_METHOD(SolrQuery,__construct)46 PHP_METHOD(SolrQuery, __construct)
47 {
48 long int params_index = SOLR_UNIQUE_PARAMS_INDEX();
49 solr_char_t *q = NULL;
50 COMPAT_ARG_SIZE_T query_length = 0;
51 solr_params_t solr_params;
52
53 zend_error_handling error_handling;
54
55 zend_replace_error_handling(EH_THROW, solr_ce_SolrIllegalArgumentException, &error_handling);
56 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &q, &query_length) == FAILURE) {
57 zend_restore_error_handling(&error_handling);
58 return;
59 }
60 zend_restore_error_handling(&error_handling);
61
62 if (solr_init_params(&solr_params, params_index) == FAILURE) {
63 return;
64 }
65
66 zend_update_property_long(solr_ce_SolrQuery, OBJ_FOR_PROP(getThis()), SOLR_INDEX_PROPERTY_NAME, sizeof(SOLR_INDEX_PROPERTY_NAME) - 1, params_index);
67
68 if (query_length) {
69
70 if (solr_set_normal_param(getThis(), (solr_char_t *) "q", sizeof("q")-1, q, query_length) == FAILURE) {
71
72 php_error_docref(NULL, E_WARNING, "Error while setting query parameter");
73
74 return;
75 }
76 }
77 }
78 /* }}} */
79
80 /* {{{ proto SolrQuery::__destruct()
81 Destructor for SolrQuery */
PHP_METHOD(SolrQuery,__destruct)82 PHP_METHOD(SolrQuery, __destruct)
83 {
84 solr_params_t *solr_params = NULL;
85
86 /* Retrieve the entry for this SolrParams instance */
87 if (solr_fetch_params_entry(getThis(), &solr_params) == SUCCESS) {
88
89 zend_hash_index_del(SOLR_GLOBAL(params), solr_params->params_index);
90
91 return ;
92 }
93
94 /* This would only happen if user attempted an illegal operation */
95 php_error_docref(NULL, E_ERROR, SOLR_ERROR_1008_MSG, SOLR_FILE_LINE_FUNC);
96 }
97 /* }}} */
98
99 /* {{{ CommonQueryParameters */
100
101 /* {{{ proto SolrQuery SolrQuery::setQuery(string q)
102 Sets the q parameter */
PHP_METHOD(SolrQuery,setQuery)103 PHP_METHOD(SolrQuery, setQuery)
104 {
105 solr_char_t *param_name = (solr_char_t *) "q";
106 COMPAT_ARG_SIZE_T param_name_len = sizeof("q")-1;
107 solr_char_t *param_value = NULL;
108 COMPAT_ARG_SIZE_T param_value_len = 0;
109
110 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
111
112 php_error_docref(NULL, E_WARNING, "Invalid parameters");
113
114 RETURN_NULL();
115 }
116
117 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE) {
118
119 RETURN_NULL();
120 }
121 solr_return_solr_params_object();
122 }
123 /* }}} */
124
125 /* {{{ proto SolrQuery SolrQuery::setStart(int start)
126 Sets the start parameter */
PHP_METHOD(SolrQuery,setStart)127 PHP_METHOD(SolrQuery, setStart)
128 {
129 solr_char_t *param_name = (solr_char_t *) "start";
130 COMPAT_ARG_SIZE_T param_name_len = sizeof("start")-1;
131 solr_char_t *param_value = NULL;
132 COMPAT_ARG_SIZE_T param_value_len = 0;
133
134 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
135
136 php_error_docref(NULL, E_WARNING, "Invalid parameters");
137
138 RETURN_NULL();
139 }
140
141 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
142 {
143 RETURN_NULL();
144 }
145
146 solr_return_solr_params_object();
147 }
148 /* }}} */
149
150 /* {{{ proto SolrQuery SolrQuery::setRows(int rows)
151 Sets the rows parameter */
PHP_METHOD(SolrQuery,setRows)152 PHP_METHOD(SolrQuery, setRows)
153 {
154 solr_char_t *param_name = (solr_char_t *) "rows";
155 COMPAT_ARG_SIZE_T param_name_len = sizeof("rows")-1;
156 solr_char_t *param_value = NULL;
157 COMPAT_ARG_SIZE_T param_value_len = 0;
158
159 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
160
161 php_error_docref(NULL, E_WARNING, "Invalid parameters");
162
163 RETURN_NULL();
164 }
165
166 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
167 {
168 RETURN_NULL();
169 }
170
171 solr_return_solr_params_object();
172 }
173 /* }}} */
174
175 /* {{{ proto SolrQuery SolrQuery::addField(string fl)
176 Adds another fl parameter */
PHP_METHOD(SolrQuery,addField)177 PHP_METHOD(SolrQuery, addField)
178 {
179 solr_char_t *param_name = (solr_char_t *) "fl";
180 size_t param_name_len = sizeof("fl")-1;
181 solr_char_t *param_value = NULL;
182 size_t param_value_len = 0;
183
184 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
185
186 php_error_docref(NULL, E_WARNING, "Invalid parameters");
187
188 RETURN_NULL();
189 }
190
191 if (solr_add_simple_list_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
192 {
193 RETURN_NULL();
194 }
195 solr_return_solr_params_object();
196 }
197 /* }}} */
198
199 /* {{{ proto SolrQuery SolrQuery::addSortField(string fl [, int sort_direction])
200 Adds another sort parameter */
PHP_METHOD(SolrQuery,addSortField)201 PHP_METHOD(SolrQuery, addSortField)
202 {
203 solr_char_t *param_name = (solr_char_t *) "sort";
204 COMPAT_ARG_SIZE_T param_name_len = sizeof("sort")-1;
205 solr_char_t *param_value = NULL;
206 COMPAT_ARG_SIZE_T param_value_len = 0;
207 long int sort_direction = 1L;
208 solr_sort_dir_t sort_order = SOLR_SORT_DIR_DESC;
209 solr_char_t *avalue = NULL;
210 COMPAT_ARG_SIZE_T avalue_length = 0;
211
212 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", ¶m_value, ¶m_value_len, &sort_direction) == FAILURE) {
213
214 php_error_docref(NULL, E_WARNING, "Invalid parameters");
215
216 RETURN_NULL();
217 }
218
219 sort_order = (sort_direction < 0L || sort_direction > 1L) ? SOLR_SORT_DIR_DESC : (solr_sort_dir_t) sort_direction;
220 avalue = (sort_order) ? "desc" : "asc";
221 avalue_length = solr_strlen(avalue);
222
223 if (solr_add_arg_list_param(getThis(), param_name, param_name_len, param_value, param_value_len, avalue, avalue_length, ',', ' ') == FAILURE)
224 {
225 RETURN_NULL();
226 }
227
228 solr_return_solr_params_object();
229 }
230 /* }}} */
231
232 /* {{{ proto SolrQuery SolrQuery::addFiterQuery(string fq)
233 Adds another fq parameter */
PHP_METHOD(SolrQuery,addFilterQuery)234 PHP_METHOD(SolrQuery, addFilterQuery)
235 {
236 solr_char_t *param_name = (solr_char_t *) "fq";
237 COMPAT_ARG_SIZE_T param_name_len = sizeof("fq")-1;
238 solr_char_t *param_value = NULL;
239 COMPAT_ARG_SIZE_T param_value_len = 0;
240
241 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
242
243 php_error_docref(NULL, E_WARNING, "Invalid parameters");
244
245 RETURN_NULL();
246 }
247
248 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
249 {
250 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, param_value);
251
252 RETURN_NULL();
253 }
254
255 solr_return_solr_params_object();
256 }
257 /* }}} */
258
259 /* {{{ proto SolrQuery SolrQuery::setShowDebugInfo(bool flag)
260 Sets the debugQuery parameter */
PHP_METHOD(SolrQuery,setShowDebugInfo)261 PHP_METHOD(SolrQuery, setShowDebugInfo)
262 {
263 solr_char_t *param_name = (solr_char_t *) "debugQuery";
264 COMPAT_ARG_SIZE_T param_name_len = sizeof("debugQuery")-1;
265 zend_bool show_debug_info = 0;
266
267 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &show_debug_info) == FAILURE) {
268
269 php_error_docref(NULL, E_WARNING, "Invalid parameters");
270
271 RETURN_NULL();
272 }
273
274 if (!show_debug_info)
275 {
276 solr_delete_solr_parameter(getThis(), param_name, param_name_len);
277
278 solr_return_solr_params_object();
279
280 return;
281 }
282
283 if (solr_set_normal_param(getThis(), param_name, param_name_len, "true", sizeof("true")-1) == FAILURE)
284 {
285 php_error_docref(NULL, E_WARNING, "Error adding debugging info ");
286
287 RETURN_NULL();
288 }
289
290 solr_return_solr_params_object();
291 }
292 /* }}} */
293
294 /* {{{ proto SolrQuery SolrQuery::setExplainOther(string explainOther)
295 Sets the explainOther parameter */
PHP_METHOD(SolrQuery,setExplainOther)296 PHP_METHOD(SolrQuery, setExplainOther)
297 {
298 solr_char_t *param_name = (solr_char_t *) "explainOther";
299 COMPAT_ARG_SIZE_T param_name_len = sizeof("explainOther")-1;
300 solr_char_t *param_value = NULL;
301 COMPAT_ARG_SIZE_T param_value_len = 0;
302
303 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
304
305 php_error_docref(NULL, E_WARNING, "Invalid parameters");
306
307 RETURN_NULL();
308 }
309
310 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
311 {
312 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, param_value);
313
314 RETURN_NULL();
315 }
316
317 solr_return_solr_params_object();
318 }
319 /* }}} */
320
321 /* {{{ proto SolrQuery SolrQuery::setTimeAllowed(int milliseconds)
322 Sets the maximum time in milliseconds allowed for the query */
PHP_METHOD(SolrQuery,setTimeAllowed)323 PHP_METHOD(SolrQuery, setTimeAllowed)
324 {
325 solr_char_t *param_name = (solr_char_t *) "timeAllowed";
326 COMPAT_ARG_SIZE_T param_name_len = sizeof("timeAllowed")-1;
327 solr_char_t *param_value = NULL;
328 COMPAT_ARG_SIZE_T param_value_len = 0;
329
330 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
331
332 php_error_docref(NULL, E_WARNING, "Invalid parameters");
333
334 RETURN_NULL();
335 }
336
337 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
338 {
339 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, param_value);
340
341 RETURN_NULL();
342 }
343
344 solr_return_solr_params_object();
345 }
346 /* }}} */
347
348 /* {{{ proto SolrQuery SolrQuery::setOmitHeader(bool flag)
349 Sets the omitHeader parameter */
PHP_METHOD(SolrQuery,setOmitHeader)350 PHP_METHOD(SolrQuery, setOmitHeader)
351 {
352 solr_char_t *param_name = (solr_char_t *) "omitHeader";
353 COMPAT_ARG_SIZE_T param_name_len = sizeof("omitHeader")-1;
354 COMPAT_ARG_SIZE_T param_value_len = 0;
355 zend_bool omit_header = 0;
356 solr_char_t *omit_header_str = NULL;
357
358 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &omit_header) == FAILURE) {
359
360 php_error_docref(NULL, E_WARNING, "Invalid parameter");
361
362 RETURN_NULL();
363 }
364
365 omit_header_str = (omit_header)? "true" : "false";
366 param_value_len = solr_strlen(omit_header_str);
367
368 if (solr_set_normal_param(getThis(), param_name, param_name_len, omit_header_str, param_value_len) == FAILURE)
369 {
370 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, omit_header_str);
371
372 RETURN_NULL();
373 }
374
375 solr_return_solr_params_object();
376 }
377 /* }}} */
378
379 /* }}} END OF CommonQueryParameters */
380
381 /* {{{ CoreQueryParameters */
382
383 /* {{{ proto SolrQuery SolrQuery::setEchoHandler(bool flag)
384 Sets the echoHandler parameter */
PHP_METHOD(SolrQuery,setEchoHandler)385 PHP_METHOD(SolrQuery, setEchoHandler)
386 {
387 solr_char_t *param_name = (solr_char_t *) "echoHandler";
388 COMPAT_ARG_SIZE_T param_name_len = sizeof("echoHandler")-1;
389 COMPAT_ARG_SIZE_T param_value_len = 0;
390 zend_bool echo_handler = 0;
391 solr_char_t *echo_handler_str = NULL;
392
393 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &echo_handler) == FAILURE) {
394
395 php_error_docref(NULL, E_WARNING, "Invalid parameter");
396
397 RETURN_NULL();
398 }
399
400 echo_handler_str = (echo_handler)? "true" : "false";
401 param_value_len = solr_strlen(echo_handler_str);
402
403 if (solr_set_normal_param(getThis(), param_name, param_name_len, echo_handler_str, param_value_len) == FAILURE)
404 {
405 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, echo_handler_str);
406
407 RETURN_NULL();
408 }
409
410 solr_return_solr_params_object();
411 }
412 /* }}} */
413
414
415 /* {{{ proto SolrQuery SolrQuery::setEchoParams(string value)
416 Sets the echoParams parameter */
PHP_METHOD(SolrQuery,setEchoParams)417 PHP_METHOD(SolrQuery, setEchoParams)
418 {
419 solr_char_t *param_name = (solr_char_t *) "echoParams";
420 COMPAT_ARG_SIZE_T param_name_len = sizeof("echoParams")-1;
421 solr_char_t *param_value = NULL;
422 COMPAT_ARG_SIZE_T param_value_len = 0;
423
424 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
425
426 php_error_docref(NULL, E_WARNING, "Invalid parameters");
427
428 RETURN_NULL();
429 }
430
431 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE) {
432
433 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, param_value);
434
435 RETURN_NULL();
436 }
437
438 solr_return_solr_params_object();
439 }
440 /* }}} */
441
442 /* }}} END OF CoreQueryParameters */
443
444 /* {{{ SimpleFacetParameters */
445
446 /* {{{ proto SolrQuery SolrQuery::setFacet(bool value)
447 Sets the facet parameter */
PHP_METHOD(SolrQuery,setFacet)448 PHP_METHOD(SolrQuery, setFacet)
449 {
450 solr_char_t *param_name = (solr_char_t *) "facet";
451 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet")-1;
452 zend_bool bool_flag = 0;
453 solr_char_t *bool_flag_str = NULL;
454 COMPAT_ARG_SIZE_T param_value_len = 0;
455
456 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
457
458 php_error_docref(NULL, E_WARNING, "Invalid parameter");
459
460 RETURN_NULL();
461 }
462
463 bool_flag_str = ((bool_flag)? "true" : "false");
464 param_value_len = solr_strlen(bool_flag_str);
465
466 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
467 {
468 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
469
470 RETURN_NULL();
471 }
472
473 solr_return_solr_params_object();
474 }
475 /* }}} */
476
477 /* {{{ proto SolrQuery SolrQuery::addFacetField(string value)
478 Sets the facet.field parameter */
PHP_METHOD(SolrQuery,addFacetField)479 PHP_METHOD(SolrQuery, addFacetField)
480 {
481 solr_char_t *param_name = (solr_char_t *) "facet.field";
482 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet.field")-1;
483 solr_char_t *param_value = NULL;
484 COMPAT_ARG_SIZE_T param_value_len = 0;
485
486 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
487
488 php_error_docref(NULL, E_WARNING, "Invalid parameters");
489
490 RETURN_NULL();
491 }
492
493 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
494 {
495 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
496
497 RETURN_NULL();
498 }
499
500 solr_return_solr_params_object();
501 }
502 /* }}} */
503
504 /* {{{ proto SolrQuery SolrQuery::addFacetQuery(string value)
505 Adds another facet.query parameter */
PHP_METHOD(SolrQuery,addFacetQuery)506 PHP_METHOD(SolrQuery, addFacetQuery)
507 {
508 solr_char_t *param_name = (solr_char_t *) "facet.query";
509 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet.query")-1;
510 solr_char_t *param_value = NULL;
511 COMPAT_ARG_SIZE_T param_value_len = 0;
512
513 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
514
515 php_error_docref(NULL, E_WARNING, "Invalid parameters");
516
517 RETURN_NULL();
518 }
519
520 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
521 {
522 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
523
524 RETURN_NULL();
525 }
526
527 solr_return_solr_params_object();
528 }
529 /* }}} */
530
531 /* {{{ proto SolrQuery SolrQuery::setFacetPrefix(string value [, string field_override])
532 Sets the facet.prefix parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetPrefix)533 PHP_METHOD(SolrQuery, setFacetPrefix)
534 {
535 solr_string_t fbuf; /* Field name buffer to prepare field override */
536
537 /* Parameter value */
538 solr_char_t *param_value = NULL;
539 COMPAT_ARG_SIZE_T param_value_len = 0;
540
541 /* Field name override,f if any */
542 solr_char_t *field_name = NULL;
543 COMPAT_ARG_SIZE_T field_name_len = 0;
544
545 memset(&fbuf, 0, sizeof(solr_string_t));
546
547 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
548
549 php_error_docref(NULL, E_WARNING, "Invalid parameters");
550
551 RETURN_NULL();
552 }
553
554 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.prefix");
555
556 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
557 {
558 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
559
560 solr_string_free(&fbuf);
561
562 RETURN_NULL();
563 }
564
565 solr_string_free(&fbuf);
566
567 solr_return_solr_params_object();
568 }
569 /* }}} */
570
571 /* {{{ proto SolrQuery SolrQuery::setFacetSort(int value [, string field_override])
572 Sets the facet.sort parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetSort)573 PHP_METHOD(SolrQuery, setFacetSort)
574 {
575 solr_string_t fbuf; /* Field name buffer to prepare field override */
576
577 /* Field name override,f if any */
578 solr_char_t *field_name = NULL;
579 COMPAT_ARG_SIZE_T field_name_len = 0;
580
581 /* Parameter value */
582 solr_char_t *param_value = NULL;
583 COMPAT_ARG_SIZE_T param_value_len = 0;
584
585 long int sort_type = 0L;
586
587 memset(&fbuf, 0, sizeof(solr_string_t));
588
589 if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|s", &sort_type, &field_name, &field_name_len) == FAILURE) {
590
591 php_error_docref(NULL, E_WARNING, "Invalid parameters");
592
593 RETURN_NULL();
594 }
595
596 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.sort");
597
598 param_value = ((sort_type)? "count" : "index");
599 param_value_len = solr_strlen(param_value);
600
601 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
602 {
603 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
604
605 solr_string_free(&fbuf);
606
607 RETURN_NULL();
608 }
609
610 solr_string_free(&fbuf);
611
612 solr_return_solr_params_object();
613 }
614 /* }}} */
615
616 /* {{{ proto SolrQuery SolrQuery::setFacetLimit(string value [, string field_override])
617 Sets the facet.limit parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetLimit)618 PHP_METHOD(SolrQuery, setFacetLimit)
619 {
620 solr_string_t fbuf; /* Field name buffer to prepare field override */
621
622 /* Parameter value */
623 solr_char_t *param_value = NULL;
624 COMPAT_ARG_SIZE_T param_value_len = 0;
625
626 /* Field name override,f if any */
627 solr_char_t *field_name = NULL;
628 COMPAT_ARG_SIZE_T field_name_len = 0;
629
630 memset(&fbuf, 0, sizeof(solr_string_t));
631
632 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
633
634 php_error_docref(NULL, E_WARNING, "Invalid parameters");
635
636 RETURN_NULL();
637 }
638
639 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.limit");
640
641 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
642 {
643 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
644
645 solr_string_free(&fbuf);
646
647 RETURN_NULL();
648 }
649
650 solr_string_free(&fbuf);
651
652 solr_return_solr_params_object();
653 }
654 /* }}} */
655
656 /* {{{ proto SolrQuery SolrQuery::setFacetOffset(string value [, string field_override])
657 Sets the facet.offset parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetOffset)658 PHP_METHOD(SolrQuery, setFacetOffset)
659 {
660 solr_string_t fbuf; /* Field name buffer to prepare field override */
661
662 /* Parameter value */
663 solr_char_t *param_value = NULL;
664 COMPAT_ARG_SIZE_T param_value_len = 0;
665
666 /* Field name override,f if any */
667 solr_char_t *field_name = NULL;
668 COMPAT_ARG_SIZE_T field_name_len = 0;
669
670 memset(&fbuf, 0, sizeof(solr_string_t));
671
672 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
673
674 php_error_docref(NULL, E_WARNING, "Invalid parameters");
675
676 RETURN_NULL();
677 }
678
679 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.offset");
680
681 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
682 {
683 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
684
685 solr_string_free(&fbuf);
686
687 RETURN_NULL();
688 }
689
690 solr_string_free(&fbuf);
691
692 solr_return_solr_params_object();
693 }
694 /* }}} */
695
696 /* {{{ proto SolrQuery SolrQuery::setFacetMinCount(string value [, string field_override])
697 Sets the facet.mincount parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetMinCount)698 PHP_METHOD(SolrQuery, setFacetMinCount)
699 {
700 solr_string_t fbuf; /* Field name buffer to prepare field override */
701
702 /* Parameter value */
703 solr_char_t *param_value = NULL;
704 COMPAT_ARG_SIZE_T param_value_len = 0;
705
706 /* Field name override,f if any */
707 solr_char_t *field_name = NULL;
708 COMPAT_ARG_SIZE_T field_name_len = 0;
709
710 memset(&fbuf, 0, sizeof(solr_string_t));
711
712 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
713
714 php_error_docref(NULL, E_WARNING, "Invalid parameters");
715
716 RETURN_NULL();
717 }
718
719 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.mincount");
720
721 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
722 {
723 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
724
725 solr_string_free(&fbuf);
726
727 RETURN_NULL();
728 }
729
730 solr_string_free(&fbuf);
731
732 solr_return_solr_params_object();
733 }
734 /* }}} */
735
736 /* {{{ proto SolrQuery SolrQuery::setFacetMissing(bool value [, string field_override])
737 Sets the facet.missing parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetMissing)738 PHP_METHOD(SolrQuery, setFacetMissing)
739 {
740 solr_string_t fbuf; /* Field name buffer to prepare field override */
741
742 /* Field name override,f if any */
743 solr_char_t *field_name = NULL;
744 COMPAT_ARG_SIZE_T field_name_len = 0;
745
746 /* Parameter value */
747 solr_char_t *param_value = NULL;
748 COMPAT_ARG_SIZE_T param_value_len = 0;
749
750 zend_bool bool_flag = 0;
751
752 memset(&fbuf, 0, sizeof(solr_string_t));
753
754 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b|s", &bool_flag, &field_name, &field_name_len) == FAILURE) {
755
756 php_error_docref(NULL, E_WARNING, "Invalid parameters");
757
758 RETURN_NULL();
759 }
760
761 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.missing");
762
763 param_value = ((bool_flag)? "true" : "false");
764 param_value_len = solr_strlen(param_value);
765
766 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
767 {
768 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
769
770 solr_string_free(&fbuf);
771
772 RETURN_NULL();
773 }
774
775 solr_string_free(&fbuf);
776
777 solr_return_solr_params_object();
778 }
779 /* }}} */
780
781 /* {{{ proto SolrQuery SolrQuery::setFacetMethod(string value [, string field_override])
782 Sets the facet.method parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetMethod)783 PHP_METHOD(SolrQuery, setFacetMethod)
784 {
785 solr_string_t fbuf; /* Field name buffer to prepare field override */
786
787 /* Parameter value */
788 solr_char_t *param_value = NULL;
789 COMPAT_ARG_SIZE_T param_value_len = 0;
790
791 /* Field name override,f if any */
792 solr_char_t *field_name = NULL;
793 COMPAT_ARG_SIZE_T field_name_len = 0;
794
795 memset(&fbuf, 0, sizeof(solr_string_t));
796
797 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
798
799 php_error_docref(NULL, E_WARNING, "Invalid parameters");
800
801 RETURN_NULL();
802 }
803
804 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.method");
805
806 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
807 {
808 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
809
810 solr_string_free(&fbuf);
811
812 RETURN_NULL();
813 }
814
815 solr_string_free(&fbuf);
816
817 solr_return_solr_params_object();
818 }
819 /* }}} */
820
821 /* {{{ proto SolrQuery SolrQuery::setFacetEnumCacheMinDefaultFrequency(string value [, string field_override])
822 Sets the facet.enum.cache.minDf parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetEnumCacheMinDefaultFrequency)823 PHP_METHOD(SolrQuery, setFacetEnumCacheMinDefaultFrequency)
824 {
825 solr_string_t fbuf; /* Field name buffer to prepare field override */
826
827 /* Parameter value */
828 solr_char_t *param_value = NULL;
829 COMPAT_ARG_SIZE_T param_value_len = 0;
830
831 /* Field name override,f if any */
832 solr_char_t *field_name = NULL;
833 COMPAT_ARG_SIZE_T field_name_len = 0;
834
835 memset(&fbuf, 0, sizeof(solr_string_t));
836
837 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
838
839 php_error_docref(NULL, E_WARNING, "Invalid parameters");
840
841 RETURN_NULL();
842 }
843
844 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.enum.cache.minDf");
845
846 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
847 {
848 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
849
850 solr_string_free(&fbuf);
851
852 RETURN_NULL();
853 }
854
855 solr_string_free(&fbuf);
856
857 solr_return_solr_params_object();
858
859 }
860 /* }}} */
861
862 /* {{{ Date facet parameters */
863
864 /* {{{ proto SolrQuery SolrQuery::addFacetDateField(string value)
865 Adds another facet.date parameter. */
PHP_METHOD(SolrQuery,addFacetDateField)866 PHP_METHOD(SolrQuery, addFacetDateField)
867 {
868 solr_char_t *param_name = (solr_char_t *) "facet.date";
869 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet.date")-1;
870 solr_char_t *param_value = NULL;
871 COMPAT_ARG_SIZE_T param_value_len = 0;
872
873 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
874
875 php_error_docref(NULL, E_WARNING, "Invalid parameters");
876
877 RETURN_NULL();
878 }
879
880 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
881 {
882 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
883
884 RETURN_NULL();
885 }
886
887 solr_return_solr_params_object();
888 }
889 /* }}} */
890
891 /* {{{ proto SolrQuery SolrQuery::setFacetDateStart(string value [, string field_override])
892 Sets the facet.date.start parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetDateStart)893 PHP_METHOD(SolrQuery, setFacetDateStart)
894 {
895 solr_string_t fbuf; /* Field name buffer to prepare field override */
896
897 /* Parameter value */
898 solr_char_t *param_value = NULL;
899 COMPAT_ARG_SIZE_T param_value_len = 0;
900
901 /* Field name override,f if any */
902 solr_char_t *field_name = NULL;
903 COMPAT_ARG_SIZE_T field_name_len = 0;
904
905 memset(&fbuf, 0, sizeof(solr_string_t));
906
907 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
908
909 php_error_docref(NULL, E_WARNING, "Invalid parameters");
910
911 RETURN_NULL();
912 }
913
914 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.date.start");
915
916 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
917 {
918 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
919
920 solr_string_free(&fbuf);
921
922 RETURN_NULL();
923 }
924
925 solr_string_free(&fbuf);
926
927 solr_return_solr_params_object();
928 }
929 /* }}} */
930
931 /* {{{ proto SolrQuery SolrQuery::setFacetDateEnd(string value [, string field_override])
932 Sets the facet.date.end parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetDateEnd)933 PHP_METHOD(SolrQuery, setFacetDateEnd)
934 {
935 solr_string_t fbuf; /* Field name buffer to prepare field override */
936
937 /* Parameter value */
938 solr_char_t *param_value = NULL;
939 COMPAT_ARG_SIZE_T param_value_len = 0;
940
941 /* Field name override,f if any */
942 solr_char_t *field_name = NULL;
943 COMPAT_ARG_SIZE_T field_name_len = 0;
944
945 memset(&fbuf, 0, sizeof(solr_string_t));
946
947 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
948
949 php_error_docref(NULL, E_WARNING, "Invalid parameters");
950
951 RETURN_NULL();
952 }
953
954 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.date.end");
955
956 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
957 {
958 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
959
960 solr_string_free(&fbuf);
961
962 RETURN_NULL();
963 }
964
965 solr_string_free(&fbuf);
966
967 solr_return_solr_params_object();
968 }
969 /* }}} */
970
971 /* {{{ proto SolrQuery SolrQuery::setFacetDateGap(string value [, string field_override])
972 Sets the facet.date.gap parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetDateGap)973 PHP_METHOD(SolrQuery, setFacetDateGap)
974 {
975 solr_string_t fbuf; /* Field name buffer to prepare field override */
976
977 /* Parameter value */
978 solr_char_t *param_value = NULL;
979 COMPAT_ARG_SIZE_T param_value_len = 0;
980
981 /* Field name override,f if any */
982 solr_char_t *field_name = NULL;
983 COMPAT_ARG_SIZE_T field_name_len = 0;
984
985 memset(&fbuf, 0, sizeof(solr_string_t));
986
987 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
988
989 php_error_docref(NULL, E_WARNING, "Invalid parameters");
990
991 RETURN_NULL();
992 }
993
994 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.date.gap");
995
996 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
997 {
998 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
999
1000 solr_string_free(&fbuf);
1001
1002 RETURN_NULL();
1003 }
1004
1005 solr_string_free(&fbuf);
1006
1007 solr_return_solr_params_object();
1008 }
1009 /* }}} */
1010
1011 /* {{{ proto SolrQuery SolrQuery::setFacetDateHardEnd(bool value [, string field_override])
1012 Sets the facet.date.hardend parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setFacetDateHardEnd)1013 PHP_METHOD(SolrQuery, setFacetDateHardEnd)
1014 {
1015 solr_string_t fbuf; /* Field name buffer to prepare field override */
1016
1017 /* Field name override,f if any */
1018 solr_char_t *field_name = NULL;
1019 COMPAT_ARG_SIZE_T field_name_len = 0;
1020
1021 /* Parameter value */
1022 solr_char_t *param_value = NULL;
1023 COMPAT_ARG_SIZE_T param_value_len = 0;
1024
1025 zend_bool bool_flag = 0;
1026
1027 memset(&fbuf, 0, sizeof(solr_string_t));
1028
1029 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b|s", &bool_flag, &field_name, &field_name_len) == FAILURE) {
1030
1031 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1032
1033 RETURN_NULL();
1034 }
1035
1036 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.date.hardend");
1037
1038 param_value = ((bool_flag)? "true" : "false");
1039 param_value_len = solr_strlen(param_value);
1040
1041 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
1042 {
1043 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
1044
1045 solr_string_free(&fbuf);
1046
1047 RETURN_NULL();
1048 }
1049
1050 solr_string_free(&fbuf);
1051
1052 solr_return_solr_params_object();
1053 }
1054 /* }}} */
1055
1056 /* {{{ proto SolrQuery SolrQuery::addFacetDateOther(string value [, string field_override])
1057 Sets the facet.date.other parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,addFacetDateOther)1058 PHP_METHOD(SolrQuery, addFacetDateOther)
1059 {
1060 solr_string_t fbuf; /* Field name buffer to prepare field override */
1061
1062 /* Parameter value */
1063 solr_char_t *param_value = NULL;
1064 COMPAT_ARG_SIZE_T param_value_len = 0;
1065
1066 /* Field name override,f if any */
1067 solr_char_t *field_name = NULL;
1068 COMPAT_ARG_SIZE_T field_name_len = 0;
1069
1070 memset(&fbuf, 0, sizeof(solr_string_t));
1071
1072 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
1073
1074 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1075
1076 RETURN_NULL();
1077 }
1078
1079 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.date.other");
1080
1081 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
1082 {
1083 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
1084
1085 solr_string_free(&fbuf);
1086
1087 RETURN_NULL();
1088 }
1089
1090 solr_string_free(&fbuf);
1091
1092 solr_return_solr_params_object();
1093 }
1094 /* }}} */
1095
1096 /* }}} End of date facet parameters */
1097
1098 /* }}} End of SimpleFacetParameters */
1099
1100
1101
1102 /* {{{ SimpleGroupParameters */
1103
1104 /* {{{ proto SolrQuery SolrQuery::setGroup(bool value)
1105 Enable result grouping (group parameter) */
PHP_METHOD(SolrQuery,setGroup)1106 PHP_METHOD(SolrQuery, setGroup)
1107 {
1108 solr_char_t *param_name = (solr_char_t *) "group";
1109 COMPAT_ARG_SIZE_T param_name_len = sizeof("group")-1;
1110 zend_bool bool_flag = 0;
1111 solr_char_t *bool_flag_str = NULL;
1112 COMPAT_ARG_SIZE_T param_value_len = 0;
1113
1114 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
1115
1116 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1117
1118 RETURN_NULL();
1119 }
1120
1121 bool_flag_str = ((bool_flag)? "true" : "false");
1122 param_value_len = solr_strlen(bool_flag_str);
1123
1124 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
1125 {
1126 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
1127
1128 RETURN_NULL();
1129 }
1130
1131 solr_return_solr_params_object();
1132 }
1133 /* }}} */
1134
1135 /* {{{ proto bool SolrQuery::getGroup()
1136 Returns true if grouping is enabled */
PHP_METHOD(SolrQuery,getGroup)1137 PHP_METHOD(SolrQuery, getGroup)
1138 {
1139
1140 solr_char_t *param_name = (solr_char_t *) "group";
1141 COMPAT_ARG_SIZE_T param_name_len = sizeof("group")-1;
1142 solr_param_t *solr_param = NULL;
1143
1144 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1145
1146 RETURN_NULL();
1147 }
1148
1149 solr_normal_param_value_display_boolean(solr_param, return_value);
1150 }
1151 /* }}} */
1152
1153 /* {{{ proto SolrQuery SolrQuery::addGroupField(string value)
1154 Adds a group.field parameter */
PHP_METHOD(SolrQuery,addGroupField)1155 PHP_METHOD(SolrQuery, addGroupField)
1156 {
1157 solr_char_t *param_name = (solr_char_t *) "group.field";
1158 int param_name_len = sizeof("group.field")-1;
1159 solr_char_t *param_value = NULL;
1160 COMPAT_ARG_SIZE_T param_value_len = 0;
1161
1162 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1163
1164 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1165
1166 RETURN_NULL();
1167 }
1168
1169 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1170 {
1171 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
1172
1173 RETURN_NULL();
1174 }
1175
1176 solr_return_solr_params_object();
1177 }
1178 /* }}} */
1179
1180 /* {{{ proto string SolrQuery::getGroupFields()
1181 Returns all the group fields (group.field parameter values) */
PHP_METHOD(SolrQuery,getGroupFields)1182 PHP_METHOD(SolrQuery, getGroupFields)
1183 {
1184 solr_char_t *param_name = (solr_char_t *) "group.field";
1185 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.field")-1;
1186 solr_param_t *solr_param = NULL;
1187
1188 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1189
1190 RETURN_NULL();
1191 }
1192
1193 array_init(return_value);
1194
1195 solr_normal_param_value_display(solr_param, return_value);
1196 }
1197 /* }}} */
1198
1199 /* {{{ proto SolrQuery SolrQuery::addGroupFunction(string value)
1200 Adds a group function (group.func parameter) */
PHP_METHOD(SolrQuery,addGroupFunction)1201 PHP_METHOD(SolrQuery, addGroupFunction)
1202 {
1203 solr_char_t *param_name = (solr_char_t *) "group.func";
1204 int param_name_len = sizeof("group.func")-1;
1205 solr_char_t *param_value = NULL;
1206 COMPAT_ARG_SIZE_T param_value_len = 0;
1207
1208 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1209
1210 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1211
1212 RETURN_NULL();
1213 }
1214
1215 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1216 {
1217 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
1218
1219 RETURN_NULL();
1220 }
1221
1222 solr_return_solr_params_object();
1223 }
1224 /* }}} */
1225
1226 /* {{{ proto string SolrQuery::getGroupFunctions()
1227 Returns all the group functions (group.func parameters) */
PHP_METHOD(SolrQuery,getGroupFunctions)1228 PHP_METHOD(SolrQuery, getGroupFunctions)
1229 {
1230 solr_char_t *param_name = (solr_char_t *) "group.func";
1231 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.func")-1;
1232 solr_param_t *solr_param = NULL;
1233
1234 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1235
1236 RETURN_NULL();
1237 }
1238
1239 array_init(return_value);
1240
1241 solr_normal_param_value_display(solr_param, return_value);
1242 }
1243 /* }}} */
1244
1245 /* {{{ proto SolrQuery SolrQuery::addGroupQuery(string value)
1246 Sets the group.query parameter */
PHP_METHOD(SolrQuery,addGroupQuery)1247 PHP_METHOD(SolrQuery, addGroupQuery)
1248 {
1249 solr_char_t *param_name = (solr_char_t *) "group.query";
1250 int param_name_len = sizeof("group.query")-1;
1251 solr_char_t *param_value = NULL;
1252 COMPAT_ARG_SIZE_T param_value_len = 0;
1253
1254 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1255
1256 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1257
1258 RETURN_NULL();
1259 }
1260
1261 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1262 {
1263 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
1264
1265 RETURN_NULL();
1266 }
1267
1268 solr_return_solr_params_object();
1269 }
1270 /* }}} */
1271
1272 /* {{{ proto string SolrQuery::getGroupQueries()
1273 Returns all the group.query parameter values */
PHP_METHOD(SolrQuery,getGroupQueries)1274 PHP_METHOD(SolrQuery, getGroupQueries)
1275 {
1276 solr_char_t *param_name = (solr_char_t *) "group.query";
1277 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.query")-1;
1278 solr_param_t *solr_param = NULL;
1279
1280 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1281
1282 RETURN_NULL();
1283 }
1284
1285 array_init(return_value);
1286
1287 solr_normal_param_value_display(solr_param, return_value);
1288 }
1289 /* }}} */
1290
1291 /* {{{ proto SolrQuery SolrQuery::setGroupLimit(string value)
1292 Sets the group.limit parameter. */
PHP_METHOD(SolrQuery,setGroupLimit)1293 PHP_METHOD(SolrQuery, setGroupLimit)
1294 {
1295
1296 solr_char_t *param_name = (solr_char_t *) "group.limit";
1297 int param_name_len = sizeof("group.limit")-1;
1298 solr_char_t *param_value = NULL;
1299 COMPAT_ARG_SIZE_T param_value_len = 0;
1300
1301 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1302
1303 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1304
1305 RETURN_NULL();
1306 }
1307
1308 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1309 {
1310 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
1311
1312 RETURN_NULL();
1313 }
1314
1315 solr_return_solr_params_object();
1316 }
1317 /* }}} */
1318
1319 /* {{{ proto int SolrQuery::getGroupLimit()
1320 Returns the group.limit value */
PHP_METHOD(SolrQuery,getGroupLimit)1321 PHP_METHOD(SolrQuery, getGroupLimit)
1322 {
1323
1324 solr_char_t *param_name = (solr_char_t *) "group.limit";
1325 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.limit")-1;
1326 solr_param_t *solr_param = NULL;
1327
1328 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1329
1330 RETURN_NULL();
1331 }
1332
1333 solr_normal_param_value_display_integer(solr_param, return_value);
1334 }
1335 /* }}} */
1336
1337 /* {{{ proto SolrQuery SolrQuery::setGroupOffset(int offset)
1338 Sets the group.offset parameter. */
PHP_METHOD(SolrQuery,setGroupOffset)1339 PHP_METHOD(SolrQuery, setGroupOffset)
1340 {
1341
1342 solr_char_t *param_name = (solr_char_t *) "group.offset";
1343 int param_name_len = sizeof("group.offset")-1;
1344 solr_char_t *param_value = NULL;
1345 COMPAT_ARG_SIZE_T param_value_len = 0;
1346
1347 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1348
1349 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1350
1351 RETURN_NULL();
1352 }
1353
1354 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1355 {
1356 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
1357
1358 RETURN_NULL();
1359 }
1360
1361 solr_return_solr_params_object();
1362 }
1363 /* }}} */
1364
1365 /* {{{ proto int SolrQuery::getGroupOffset()
1366 Returns the group.offset value */
PHP_METHOD(SolrQuery,getGroupOffset)1367 PHP_METHOD(SolrQuery, getGroupOffset)
1368 {
1369
1370 solr_char_t *param_name = (solr_char_t *) "group.offset";
1371 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.offset")-1;
1372 solr_param_t *solr_param = NULL;
1373
1374 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1375
1376 RETURN_NULL();
1377 }
1378
1379 solr_normal_param_value_display_integer(solr_param, return_value);
1380 }
1381 /* }}} */
1382
1383 /* {{{ proto SolrQuery SolrQuery::addGroupSortField(string sort[, integer direction])
1384 Add a group sort field (group.sort parameter). */
PHP_METHOD(SolrQuery,addGroupSortField)1385 PHP_METHOD(SolrQuery, addGroupSortField)
1386 {
1387
1388 solr_char_t *param_name = (solr_char_t *) "group.sort";
1389 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.sort")-1;
1390 solr_char_t *param_value = NULL;
1391 COMPAT_ARG_SIZE_T param_value_len = 0;
1392 long int sort_direction = 1L;
1393 solr_sort_dir_t sort_order = SOLR_SORT_DIR_DESC;
1394 solr_char_t *avalue = NULL;
1395 COMPAT_ARG_SIZE_T avalue_length = 0;
1396
1397 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", ¶m_value, ¶m_value_len, &sort_direction) == FAILURE) {
1398
1399 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1400
1401 RETURN_NULL();
1402 }
1403
1404 sort_order = (sort_direction < 0L || sort_direction > 1L) ? SOLR_SORT_DIR_DESC : (solr_sort_dir_t) sort_direction;
1405 avalue = (sort_order) ? "desc" : "asc";
1406 avalue_length = solr_strlen(avalue);
1407
1408 if (solr_add_arg_list_param(getThis(), param_name, param_name_len, param_value, param_value_len, avalue, avalue_length, ',', ' ') == FAILURE)
1409 {
1410 RETURN_NULL();
1411 }
1412
1413 solr_return_solr_params_object();
1414 }
1415 /* }}} */
1416
1417 /* {{{ proto array SolrQuery::getGroupSortFields()
1418 Returns the group.sort value */
PHP_METHOD(SolrQuery,getGroupSortFields)1419 PHP_METHOD(SolrQuery, getGroupSortFields)
1420 {
1421
1422 solr_char_t *param_name = (solr_char_t *) "group.sort";
1423 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.sort")-1;
1424 solr_param_t *solr_param = NULL;
1425
1426 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1427
1428 RETURN_NULL();
1429 }
1430
1431 array_init(return_value);
1432
1433 solr_arg_list_param_value_display(solr_param, return_value);
1434 }
1435 /* }}} */
1436
1437 /* {{{ proto SolrQuery SolrQuery::setGroupFormat(string value)
1438 Sets the group.format parameter. */
PHP_METHOD(SolrQuery,setGroupFormat)1439 PHP_METHOD(SolrQuery, setGroupFormat)
1440 {
1441
1442 solr_char_t *param_name = (solr_char_t *) "group.format";
1443 int param_name_len = sizeof("group.format")-1;
1444 solr_char_t *param_value = NULL;
1445 COMPAT_ARG_SIZE_T param_value_len = 0;
1446
1447 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1448
1449 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1450
1451 RETURN_NULL();
1452 }
1453
1454 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1455 {
1456 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s ", param_value, param_name);
1457
1458 RETURN_NULL();
1459 }
1460
1461 solr_return_solr_params_object();
1462 }
1463 /* }}} */
1464
1465 /* {{{ proto string SolrQuery::getGroupFormat()
1466 Returns the group.format value */
PHP_METHOD(SolrQuery,getGroupFormat)1467 PHP_METHOD(SolrQuery, getGroupFormat)
1468 {
1469
1470 solr_char_t *param_name = (solr_char_t *) "group.format";
1471 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.format")-1;
1472 solr_param_t *solr_param = NULL;
1473
1474 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1475
1476 RETURN_NULL();
1477 }
1478
1479 solr_normal_param_value_display_string(solr_param, return_value);
1480 }
1481 /* }}} */
1482
1483
1484
1485 /* {{{ proto SolrQuery SolrQuery::setGroupMain(bool value)
1486 Sets the group.main parameter */
PHP_METHOD(SolrQuery,setGroupMain)1487 PHP_METHOD(SolrQuery, setGroupMain)
1488 {
1489 solr_char_t *param_name = (solr_char_t *) "group.main";
1490 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.main")-1;
1491 zend_bool bool_flag = 0;
1492 solr_char_t *bool_flag_str = NULL;
1493 COMPAT_ARG_SIZE_T param_value_len = 0;
1494
1495 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
1496
1497 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1498
1499 RETURN_NULL();
1500 }
1501
1502 bool_flag_str = ((bool_flag)? "true" : "false");
1503 param_value_len = solr_strlen(bool_flag_str);
1504
1505 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
1506 {
1507 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
1508
1509 RETURN_NULL();
1510 }
1511
1512 solr_return_solr_params_object();
1513 }
1514 /* }}} */
1515
1516 /* {{{ proto bool SolrQuery::getGroupMain()
1517 Returns the group.main value */
PHP_METHOD(SolrQuery,getGroupMain)1518 PHP_METHOD(SolrQuery, getGroupMain)
1519 {
1520
1521 solr_char_t *param_name = (solr_char_t *) "group.main";
1522 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.main")-1;
1523 solr_param_t *solr_param = NULL;
1524
1525 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1526
1527 RETURN_NULL();
1528 }
1529
1530 solr_normal_param_value_display_boolean(solr_param, return_value);
1531 }
1532 /* }}} */
1533
1534 /* {{{ proto SolrQuery SolrQuery::setGroupNGroups(bool value)
1535 Sets the group.ngroups parameter */
PHP_METHOD(SolrQuery,setGroupNGroups)1536 PHP_METHOD(SolrQuery, setGroupNGroups)
1537 {
1538 solr_char_t *param_name = (solr_char_t *) "group.ngroups";
1539 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.ngroups")-1;
1540 zend_bool bool_flag = 0;
1541 solr_char_t *bool_flag_str = NULL;
1542 COMPAT_ARG_SIZE_T param_value_len = 0;
1543
1544 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
1545
1546 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1547
1548 RETURN_NULL();
1549 }
1550
1551 bool_flag_str = ((bool_flag)? "true" : "false");
1552 param_value_len = solr_strlen(bool_flag_str);
1553
1554 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
1555 {
1556 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
1557
1558 RETURN_NULL();
1559 }
1560
1561 solr_return_solr_params_object();
1562 }
1563 /* }}} */
1564
1565 /* {{{ proto bool SolrQuery::getGroupNGroups()
1566 Returns the group.ngroups value */
PHP_METHOD(SolrQuery,getGroupNGroups)1567 PHP_METHOD(SolrQuery, getGroupNGroups)
1568 {
1569
1570 solr_char_t *param_name = (solr_char_t *) "group.ngroups";
1571 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.ngroups")-1;
1572 solr_param_t *solr_param = NULL;
1573
1574 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1575
1576 RETURN_NULL();
1577 }
1578
1579 solr_normal_param_value_display_boolean(solr_param, return_value);
1580 }
1581 /* }}} */
1582
1583
1584 /* {{{ proto SolrQuery SolrQuery::setGroupTruncate(bool value)
1585 Sets the group.truncate parameter */
PHP_METHOD(SolrQuery,setGroupTruncate)1586 PHP_METHOD(SolrQuery, setGroupTruncate)
1587 {
1588 solr_char_t *param_name = (solr_char_t *) "group.truncate";
1589 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.truncate")-1;
1590 zend_bool bool_flag = 0;
1591 solr_char_t *bool_flag_str = NULL;
1592 COMPAT_ARG_SIZE_T param_value_len = 0;
1593
1594 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
1595
1596 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1597
1598 RETURN_NULL();
1599 }
1600
1601 bool_flag_str = ((bool_flag)? "true" : "false");
1602 param_value_len = solr_strlen(bool_flag_str);
1603
1604 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
1605 {
1606 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
1607
1608 RETURN_NULL();
1609 }
1610
1611 solr_return_solr_params_object();
1612 }
1613 /* }}} */
1614
1615 /* {{{ proto bool SolrQuery::getGroupTruncate()
1616 Returns the group.truncate value */
PHP_METHOD(SolrQuery,getGroupTruncate)1617 PHP_METHOD(SolrQuery, getGroupTruncate)
1618 {
1619
1620 solr_char_t *param_name = (solr_char_t *) "group.truncate";
1621 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.truncate")-1;
1622 solr_param_t *solr_param = NULL;
1623
1624 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1625
1626 RETURN_NULL();
1627 }
1628
1629 solr_normal_param_value_display_boolean(solr_param, return_value);
1630 }
1631 /* }}} */
1632
1633 /* {{{ proto SolrQuery SolrQuery::setGroupFacet(bool value)
1634 Sets the group.facet parameter */
PHP_METHOD(SolrQuery,setGroupFacet)1635 PHP_METHOD(SolrQuery, setGroupFacet)
1636 {
1637 solr_char_t *param_name = (solr_char_t *) "group.facet";
1638 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.facet")-1;
1639 zend_bool bool_flag = 0;
1640 solr_char_t *bool_flag_str = NULL;
1641 COMPAT_ARG_SIZE_T param_value_len = 0;
1642
1643 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
1644
1645 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1646
1647 RETURN_NULL();
1648 }
1649
1650 bool_flag_str = ((bool_flag)? "true" : "false");
1651 param_value_len = solr_strlen(bool_flag_str);
1652
1653 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
1654 {
1655 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
1656
1657 RETURN_NULL();
1658 }
1659
1660 solr_return_solr_params_object();
1661 }
1662 /* }}} */
1663
1664 /* {{{ proto bool SolrQuery::getGroupFacet()
1665 Returns the group.facet value */
PHP_METHOD(SolrQuery,getGroupFacet)1666 PHP_METHOD(SolrQuery, getGroupFacet)
1667 {
1668
1669 solr_char_t *param_name = (solr_char_t *) "group.facet";
1670 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.facet")-1;
1671 solr_param_t *solr_param = NULL;
1672
1673 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1674
1675 RETURN_NULL();
1676 }
1677
1678 solr_normal_param_value_display_boolean(solr_param, return_value);
1679 }
1680 /* }}} */
1681
1682 /* {{{ proto SolrQuery SolrQuery::setGroupCachePercent(int value)
1683 sets the group cache percent group.cache.percent value */
PHP_METHOD(SolrQuery,setGroupCachePercent)1684 PHP_METHOD(SolrQuery, setGroupCachePercent)
1685 {
1686 solr_char_t *param_name = (solr_char_t *) "group.cache.percent";
1687 COMPAT_ARG_SIZE_T param_name_len = sizeof ("group.cache.percent")-1;
1688 long cache_pct = 0;
1689 solr_char_t pval[4];
1690 int pval_len = 0;
1691
1692 if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &cache_pct)) {
1693 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1694
1695 RETURN_NULL();
1696 }
1697
1698 if (cache_pct < 0 || cache_pct > 100) {
1699 solr_throw_exception(solr_ce_SolrIllegalArgumentException, "Group cache percent must be between 0 and 100", SOLR_ERROR_4000, SOLR_FILE_LINE_FUNC);
1700 RETURN_NULL();
1701 }
1702
1703 snprintf (pval, sizeof(pval), "%ld", cache_pct);
1704
1705 pval_len = strlen(pval);
1706
1707 if (solr_add_or_set_normal_param(getThis(), param_name, param_name_len, pval, pval_len, 0)) {
1708 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, pval);
1709 efree(pval);
1710 RETURN_NULL();
1711 }
1712
1713 solr_return_solr_params_object();
1714 }
1715 /* }}} */
1716
1717 /* {{{ proto int SolrQuery::getGroupCachePercent()
1718 Gets the group cache percent group.cache.percent value */
PHP_METHOD(SolrQuery,getGroupCachePercent)1719 PHP_METHOD(SolrQuery, getGroupCachePercent)
1720 {
1721 solr_char_t *param_name = (solr_char_t *) "group.cache.percent";
1722 COMPAT_ARG_SIZE_T param_name_len = sizeof("group.cache.percent")-1;
1723 solr_param_t *solr_param = NULL;
1724
1725 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1726 RETURN_NULL();
1727 }
1728
1729 solr_normal_param_value_display_integer(solr_param, return_value);
1730 }
1731 /* }}} */
1732
1733 /* }}} End of SimpleGroupParameters */
1734
1735 /* {{{ proto SolrQuery SolrQuery::collapse(SolrCollapseFunction collapseFunction)
1736 Collapse a Solr Query
1737 */
PHP_METHOD(SolrQuery,collapse)1738 PHP_METHOD(SolrQuery, collapse)
1739 {
1740 solr_char_t *param_name = (solr_char_t *) "fq";
1741 COMPAT_ARG_SIZE_T param_name_len = sizeof("fq")-1;
1742 zval *collapse_func_obj, *obj_ref;
1743 solr_function_t *collapse_func;
1744 solr_string_t *buffer = NULL;
1745 zend_string *field_str = zend_string_init("field", sizeof("field"), SOLR_FUNCTIONS_PERSISTENT);
1746
1747 if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &obj_ref) == FAILURE) {
1748 RETURN_NULL();
1749 }
1750
1751 if (Z_TYPE_P(obj_ref) == IS_REFERENCE) {
1752 collapse_func_obj = Z_REFVAL_P(obj_ref);
1753 } else {
1754 collapse_func_obj = obj_ref;
1755 }
1756
1757 if(solr_fetch_function_entry(collapse_func_obj, &collapse_func) == FAILURE) {
1758 php_error_docref(NULL, E_ERROR, "Internal Error Unable to fetch function from functions global");
1759 RETURN_NULL();
1760 }
1761
1762 /* validate */
1763 if (!zend_hash_exists(collapse_func->params, field_str)) {
1764 solr_throw_exception_ex(solr_ce_SolrMissingMandatoryParameterException,SOLR_ERROR_4100, SOLR_FILE_LINE_FUNC, SOLR_ERROR_4100_MSG, "field");
1765 }
1766
1767 buffer = (solr_string_t *)pemalloc(sizeof(solr_string_t), SOLR_STRING_PERSISTENT);
1768 memset(buffer, 0, sizeof(solr_string_t));
1769
1770 solr_solrfunc_to_string(collapse_func, &buffer);
1771
1772 if (solr_add_or_set_normal_param(getThis(), param_name, param_name_len, buffer->str, buffer->len, 1) == FAILURE) {
1773 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, buffer->str);
1774 }
1775
1776 solr_string_free(buffer);
1777 pefree(buffer, SOLR_STRING_PERSISTENT);
1778 zend_string_release(field_str);
1779
1780 solr_return_solr_params_object();
1781 }
1782 /* }}} */
1783
1784 /* {{{ Expand Parameters */
1785
1786 /* {{{ proto SolrQuery SolrQuery::setExpand(bool value)
1787 Sets the expand parameter. This enables or disables group expanding. */
PHP_METHOD(SolrQuery,setExpand)1788 PHP_METHOD(SolrQuery, setExpand)
1789 {
1790 solr_char_t *param_name = (solr_char_t *) "expand";
1791 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand")-1;
1792 zend_bool bool_flag = 0;
1793 solr_char_t *bool_flag_str = NULL;
1794 COMPAT_ARG_SIZE_T param_value_len = 0;
1795
1796 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
1797
1798 php_error_docref(NULL, E_WARNING, "Invalid parameter");
1799
1800 RETURN_NULL();
1801 }
1802
1803 bool_flag_str = ((bool_flag)? "true" : "false");
1804 param_value_len = solr_strlen(bool_flag_str);
1805
1806 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
1807 {
1808 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
1809
1810 RETURN_NULL();
1811 }
1812
1813 solr_return_solr_params_object();
1814 }
1815 /* }}} */
1816
1817
1818 /* {{{ proto bool SolrQuery::getExpand()
1819 Returns true if group expanding is enabled */
PHP_METHOD(SolrQuery,getExpand)1820 PHP_METHOD(SolrQuery, getExpand)
1821 {
1822
1823 solr_char_t *param_name = (solr_char_t *) "expand";
1824 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand")-1;
1825 solr_param_t *solr_param = NULL;
1826
1827 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1828 RETURN_NULL();
1829 }
1830
1831 solr_normal_param_value_display_boolean(solr_param, return_value);
1832 }
1833 /* }}} */
1834
1835 /* {{{ proto SolrQuery SolrQuery::addExpandSortField(string sort[, integer direction])
1836 Orders the documents within the expanded groups (expand.sort parameter). */
PHP_METHOD(SolrQuery,addExpandSortField)1837 PHP_METHOD(SolrQuery, addExpandSortField)
1838 {
1839 solr_char_t *param_name = (solr_char_t *) "expand.sort";
1840 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.sort")-1;
1841 solr_char_t *param_value = NULL;
1842 COMPAT_ARG_SIZE_T param_value_len = 0;
1843 long int sort_direction = 1L;
1844 solr_sort_dir_t sort_order = SOLR_SORT_DIR_DESC;
1845 solr_char_t *avalue = NULL;
1846 COMPAT_ARG_SIZE_T avalue_length = 0;
1847
1848 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", ¶m_value, ¶m_value_len, &sort_direction) == FAILURE) {
1849
1850 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1851
1852 RETURN_NULL();
1853 }
1854
1855 sort_order = (sort_direction < 0L || sort_direction > 1L) ? SOLR_SORT_DIR_DESC : (solr_sort_dir_t) sort_direction;
1856 avalue = (sort_order) ? "desc" : "asc";
1857 avalue_length = solr_strlen(avalue);
1858
1859 if (solr_add_arg_list_param(getThis(), param_name, param_name_len, param_value, param_value_len, avalue, avalue_length, ',', ' ') == FAILURE)
1860 {
1861 RETURN_NULL();
1862 }
1863
1864 solr_return_solr_params_object();
1865 }
1866 /* }}} */
1867
1868 /* {{{ proto SolrQuery SolrQuery::removeExpandSortField(string field)
1869 Removes an expand sort field from the expand.sort parameter. */
PHP_METHOD(SolrQuery,removeExpandSortField)1870 PHP_METHOD(SolrQuery, removeExpandSortField)
1871 {
1872 solr_char_t *pname = (solr_char_t *) "expand.sort";
1873 int pname_length = sizeof("expand.sort")-1;
1874
1875 solr_char_t *param_value = NULL;
1876 COMPAT_ARG_SIZE_T param_value_len = 0;
1877
1878 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1879
1880 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1881
1882 RETURN_NULL();
1883 }
1884
1885 solr_delete_arg_list_param_value(getThis(), pname, pname_length, param_value, param_value_len);
1886
1887 solr_return_solr_params_object();
1888 }
1889 /* }}} */
1890
1891
1892
1893 /* {{{ proto string SolrQuery::getExpandSortFields()
1894 returns an array of fields */
PHP_METHOD(SolrQuery,getExpandSortFields)1895 PHP_METHOD(SolrQuery, getExpandSortFields)
1896 {
1897 solr_char_t *param_name = (solr_char_t *) "expand.sort";
1898 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.sort")-1;
1899 solr_param_t *solr_param = NULL;
1900
1901 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1902
1903 RETURN_NULL();
1904 }
1905
1906 array_init(return_value);
1907
1908 solr_normal_param_value_display(solr_param, return_value);
1909 }
1910 /* }}} */
1911
1912 /* {{{ proto SolrQuery SolrQuery::setExpandRows(int rows)
1913 Sets the number of rows to display in each group (expand.rows). Server Default 5 */
PHP_METHOD(SolrQuery,setExpandRows)1914 PHP_METHOD(SolrQuery, setExpandRows)
1915 {
1916 solr_char_t *param_name = (solr_char_t *) "expand.rows";
1917 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.rows")-1;
1918 solr_char_t *param_value = NULL;
1919 COMPAT_ARG_SIZE_T param_value_len = 0;
1920
1921 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1922
1923 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1924
1925 RETURN_NULL();
1926 }
1927
1928 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1929 {
1930 RETURN_NULL();
1931 }
1932
1933 solr_return_solr_params_object();
1934 }
1935 /* }}} */
1936
1937 /* {{{ proto int SolrQuery::getExpandRows()
1938 Returns The number of rows to display in each group (expand.rows) */
PHP_METHOD(SolrQuery,getExpandRows)1939 PHP_METHOD(SolrQuery, getExpandRows)
1940 {
1941
1942 solr_char_t *param_name = (solr_char_t *) "expand.rows";
1943 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.rows")-1;
1944 solr_param_t *solr_param = NULL;
1945
1946 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1947 RETURN_NULL();
1948 }
1949
1950 solr_normal_param_value_display_integer(solr_param, return_value);
1951 }
1952 /* }}} */
1953
1954
1955 /* {{{ proto SolrQuery SolrQuery::setExpandQuery(string q)
1956 Sets the expand.q parameter. Overrides the main q parameter,
1957 determines which documents to include in the main group. */
PHP_METHOD(SolrQuery,setExpandQuery)1958 PHP_METHOD(SolrQuery, setExpandQuery)
1959 {
1960 solr_char_t *param_name = (solr_char_t *) "expand.q";
1961 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.q")-1;
1962
1963 solr_char_t *param_value = NULL;
1964 COMPAT_ARG_SIZE_T param_value_len = 0;
1965
1966 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
1967
1968 php_error_docref(NULL, E_WARNING, "Invalid parameters");
1969
1970 RETURN_NULL();
1971 }
1972
1973 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
1974 {
1975 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
1976
1977 RETURN_NULL();
1978 }
1979
1980 solr_return_solr_params_object();
1981 }
1982 /* }}} */
1983
1984 /* {{{ proto string SolrQuery::getExpandQuery()
1985 Returns the expand query expand.q parameter */
PHP_METHOD(SolrQuery,getExpandQuery)1986 PHP_METHOD(SolrQuery, getExpandQuery)
1987 {
1988
1989 solr_char_t *param_name = (solr_char_t *) "expand.q";
1990 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.q")-1;
1991 solr_param_t *solr_param = NULL;
1992
1993 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
1994 RETURN_NULL();
1995 }
1996
1997 solr_normal_param_value_display_string(solr_param, return_value);
1998 }
1999 /* }}} */
2000
2001
2002 /* {{{ proto SolrQuery SolrQuery::addExpandFilterQuery(string fq)
2003 Overrides main fq's, determines which documents to include in the main group. */
PHP_METHOD(SolrQuery,addExpandFilterQuery)2004 PHP_METHOD(SolrQuery, addExpandFilterQuery)
2005 {
2006 solr_char_t *param_name = (solr_char_t *) "expand.fq";
2007 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.fq")-1;
2008 solr_char_t *param_value = NULL;
2009 COMPAT_ARG_SIZE_T param_value_len = 0;
2010
2011 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2012
2013 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2014
2015 RETURN_NULL();
2016 }
2017
2018 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2019 {
2020 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, param_value);
2021
2022 RETURN_NULL();
2023 }
2024
2025 solr_return_solr_params_object();
2026 }
2027 /* }}} */
2028
2029 /* {{{ proto SolrQuery SolrQuery::removeExpandFilterQuery(string fq)
2030 Removes an expand filter query. */
PHP_METHOD(SolrQuery,removeExpandFilterQuery)2031 PHP_METHOD(SolrQuery, removeExpandFilterQuery)
2032 {
2033 solr_char_t *pname = (solr_char_t *) "expand.fq";
2034 int pname_length = sizeof("expand.fq")-1;
2035
2036 solr_char_t *param_value = NULL;
2037 COMPAT_ARG_SIZE_T param_value_len = 0;
2038
2039 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2040
2041 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2042
2043 RETURN_NULL();
2044 }
2045
2046 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
2047
2048 solr_return_solr_params_object();
2049 }
2050 /* }}} */
2051
2052 /* {{{ proto array SolrQuery::getExpandFilterQueries()
2053 Returns the expand filter queries */
PHP_METHOD(SolrQuery,getExpandFilterQueries)2054 PHP_METHOD(SolrQuery, getExpandFilterQueries)
2055 {
2056 solr_char_t *param_name = (solr_char_t *) "expand.fq";
2057 COMPAT_ARG_SIZE_T param_name_len = sizeof("expand.fq")-1;
2058 solr_param_t *solr_param = NULL;
2059
2060 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
2061
2062 RETURN_NULL();
2063 }
2064
2065 array_init(return_value);
2066
2067 solr_normal_param_value_display(solr_param, return_value);
2068 }
2069 /* }}} */
2070
2071
2072 /* }}} */
2073
2074 /* {{{ HighlightingParameters */
2075
2076 /* {{{ proto SolrQuery SolrQuery::setHighlight(bool value)
2077 Sets the hl parameter. This enables or disables highlighting. */
PHP_METHOD(SolrQuery,setHighlight)2078 PHP_METHOD(SolrQuery, setHighlight)
2079 {
2080 solr_char_t *param_name = (solr_char_t *) "hl";
2081 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl")-1;
2082 zend_bool bool_flag = 0;
2083 solr_char_t *bool_flag_str = NULL;
2084 COMPAT_ARG_SIZE_T param_value_len = 0;
2085
2086 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
2087
2088 php_error_docref(NULL, E_WARNING, "Invalid parameter");
2089
2090 RETURN_NULL();
2091 }
2092
2093 bool_flag_str = ((bool_flag)? "true" : "false");
2094 param_value_len = solr_strlen(bool_flag_str);
2095
2096 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
2097 {
2098 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
2099
2100 RETURN_NULL();
2101 }
2102
2103 solr_return_solr_params_object();
2104 }
2105 /* }}} */
2106
2107 /* {{{ proto SolrQuery SolrQuery::addHighlightField(string value)
2108 Adds another hl.fl parameter. */
PHP_METHOD(SolrQuery,addHighlightField)2109 PHP_METHOD(SolrQuery, addHighlightField)
2110 {
2111 solr_char_t *list_param_name = (solr_char_t *) "hl.fl";
2112 COMPAT_ARG_SIZE_T list_param_name_len = sizeof("hl.fl")-1;
2113 solr_char_t *list_param_value = NULL;
2114 COMPAT_ARG_SIZE_T list_param_value_len = 0;
2115
2116 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &list_param_value, &list_param_value_len) == FAILURE) {
2117
2118 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2119
2120 RETURN_NULL();
2121 }
2122
2123 if (solr_add_simple_list_param(getThis(), list_param_name, list_param_name_len, list_param_value, list_param_value_len) == FAILURE)
2124 {
2125 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s list ", list_param_value, list_param_name);
2126
2127 RETURN_NULL();
2128 }
2129
2130 solr_return_solr_params_object();
2131 }
2132 /* }}} */
2133
2134 /* {{{ proto SolrQuery SolrQuery::setHighlightSnippets(string value [, string field_override])
2135 Sets the hl.snippets parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightSnippets)2136 PHP_METHOD(SolrQuery, setHighlightSnippets)
2137 {
2138 solr_string_t fbuf; /* Field name buffer to prepare field override */
2139
2140 /* Parameter value */
2141 solr_char_t *param_value = NULL;
2142 COMPAT_ARG_SIZE_T param_value_len = 0;
2143
2144 /* Field name override,f if any */
2145 solr_char_t *field_name = NULL;
2146 COMPAT_ARG_SIZE_T field_name_len = 0;
2147
2148 memset(&fbuf, 0, sizeof(solr_string_t));
2149
2150 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2151
2152 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2153
2154 RETURN_NULL();
2155 }
2156
2157 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.snippets");
2158
2159 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2160 {
2161 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2162
2163 solr_string_free(&fbuf);
2164
2165 RETURN_NULL();
2166 }
2167
2168 solr_string_free(&fbuf);
2169
2170 solr_return_solr_params_object();
2171 }
2172 /* }}} */
2173
2174 /* {{{ proto SolrQuery SolrQuery::setHighlightFragsize(string value [, string field_override])
2175 Sets the hl.fragsize parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightFragsize)2176 PHP_METHOD(SolrQuery, setHighlightFragsize)
2177 {
2178 solr_string_t fbuf; /* Field name buffer to prepare field override */
2179
2180 /* Parameter value */
2181 solr_char_t *param_value = NULL;
2182 COMPAT_ARG_SIZE_T param_value_len = 0;
2183
2184 /* Field name override,f if any */
2185 solr_char_t *field_name = NULL;
2186 COMPAT_ARG_SIZE_T field_name_len = 0;
2187
2188 memset(&fbuf, 0, sizeof(solr_string_t));
2189
2190 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2191
2192 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2193
2194 RETURN_NULL();
2195 }
2196
2197 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.fragsize");
2198
2199 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2200 {
2201 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2202
2203 solr_string_free(&fbuf);
2204
2205 RETURN_NULL();
2206 }
2207
2208 solr_string_free(&fbuf);
2209
2210 solr_return_solr_params_object();
2211
2212 }
2213 /* }}} */
2214
2215 /* {{{ proto SolrQuery SolrQuery::setHighlightMergeContiguous(bool flag [, string field_override])
2216 Sets the hl.mergeContiguous parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightMergeContiguous)2217 PHP_METHOD(SolrQuery, setHighlightMergeContiguous)
2218 {
2219 solr_string_t fbuf; /* Field name buffer to prepare field override */
2220
2221 /* Field name override,f if any */
2222 solr_char_t *field_name = NULL;
2223 COMPAT_ARG_SIZE_T field_name_len = 0;
2224
2225 /* Parameter value */
2226 solr_char_t *param_value = NULL;
2227 COMPAT_ARG_SIZE_T param_value_len = 0;
2228
2229 zend_bool bool_flag = 0;
2230
2231 memset(&fbuf, 0, sizeof(solr_string_t));
2232
2233 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b|s", &bool_flag, &field_name, &field_name_len) == FAILURE) {
2234
2235 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2236
2237 RETURN_NULL();
2238 }
2239
2240 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.mergeContiguous");
2241
2242 param_value = ((bool_flag)? "true" : "false");
2243 param_value_len = solr_strlen(param_value);
2244
2245 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2246 {
2247 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2248
2249 solr_string_free(&fbuf);
2250
2251 RETURN_NULL();
2252 }
2253
2254 solr_string_free(&fbuf);
2255
2256 solr_return_solr_params_object();
2257 }
2258 /* }}} */
2259
2260 /* {{{ proto SolrQuery SolrQuery::setHighlightRequireFieldMatch(bool flag)
2261 Sets the hl.requireFieldMatch. */
PHP_METHOD(SolrQuery,setHighlightRequireFieldMatch)2262 PHP_METHOD(SolrQuery, setHighlightRequireFieldMatch)
2263 {
2264 solr_char_t *param_name = (solr_char_t *) "hl.requireFieldMatch";
2265 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.requireFieldMatch")-1;
2266 zend_bool bool_flag = 0;
2267 solr_char_t *bool_flag_str = NULL;
2268 COMPAT_ARG_SIZE_T param_value_len = 0;
2269
2270 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
2271
2272 php_error_docref(NULL, E_WARNING, "Invalid parameter");
2273
2274 RETURN_NULL();
2275 }
2276
2277 bool_flag_str = ((bool_flag)? "true" : "false");
2278 param_value_len = solr_strlen(bool_flag_str);
2279
2280 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
2281 {
2282 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
2283
2284 RETURN_NULL();
2285 }
2286
2287 solr_return_solr_params_object();
2288 }
2289 /* }}} */
2290
2291 /* {{{ proto SolrQuery SolrQuery::setHighlightMaxAnalyzedChars(string value)
2292 Sets the hl.maxAnalyzedChars parameter */
PHP_METHOD(SolrQuery,setHighlightMaxAnalyzedChars)2293 PHP_METHOD(SolrQuery, setHighlightMaxAnalyzedChars)
2294 {
2295 solr_char_t *param_name = (solr_char_t *) "hl.maxAnalyzedChars";
2296 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.maxAnalyzedChars")-1;
2297 solr_char_t *param_value = NULL;
2298 COMPAT_ARG_SIZE_T param_value_len = 0;
2299
2300 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2301
2302 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2303
2304 RETURN_NULL();
2305 }
2306
2307 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2308 {
2309 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2310
2311 RETURN_NULL();
2312 }
2313
2314 solr_return_solr_params_object();
2315 }
2316 /* }}} */
2317
2318 /* {{{ proto SolrQuery SolrQuery::setHighlightAlternateField(string value [, string field_override])
2319 Sets the hl.alternateField parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightAlternateField)2320 PHP_METHOD(SolrQuery, setHighlightAlternateField)
2321 {
2322 solr_string_t fbuf; /* Field name buffer to prepare field override */
2323
2324 /* Parameter value */
2325 solr_char_t *param_value = NULL;
2326 COMPAT_ARG_SIZE_T param_value_len = 0;
2327
2328 /* Field name override,f if any */
2329 solr_char_t *field_name = NULL;
2330 COMPAT_ARG_SIZE_T field_name_len = 0;
2331
2332 memset(&fbuf, 0, sizeof(solr_string_t));
2333
2334 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2335
2336 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2337
2338 RETURN_NULL();
2339 }
2340
2341 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.alternateField");
2342
2343 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2344 {
2345 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2346
2347 solr_string_free(&fbuf);
2348
2349 RETURN_NULL();
2350 }
2351
2352 solr_string_free(&fbuf);
2353
2354 solr_return_solr_params_object();
2355 }
2356 /* }}} */
2357
2358 /* {{{ proto SolrQuery SolrQuery::setHighlightMaxAlternateFieldLength(string value [, string field_override])
2359 Sets the hl.maxAlternateFieldLength parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightMaxAlternateFieldLength)2360 PHP_METHOD(SolrQuery, setHighlightMaxAlternateFieldLength)
2361 {
2362 solr_string_t fbuf; /* Field name buffer to prepare field override */
2363
2364 /* Parameter value */
2365 solr_char_t *param_value = NULL;
2366 COMPAT_ARG_SIZE_T param_value_len = 0;
2367
2368 /* Field name override,f if any */
2369 solr_char_t *field_name = NULL;
2370 COMPAT_ARG_SIZE_T field_name_len = 0;
2371
2372 memset(&fbuf, 0, sizeof(solr_string_t));
2373
2374 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2375
2376 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2377
2378 RETURN_NULL();
2379 }
2380
2381 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.maxAlternateFieldLength");
2382
2383 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2384 {
2385 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2386
2387 solr_string_free(&fbuf);
2388
2389 RETURN_NULL();
2390 }
2391
2392 solr_string_free(&fbuf);
2393
2394 solr_return_solr_params_object();
2395 }
2396 /* }}} */
2397
2398 /* {{{ proto SolrQuery SolrQuery::setHighlightFormatter(string value [, string field_override])
2399 Sets the hl.formatter parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightFormatter)2400 PHP_METHOD(SolrQuery, setHighlightFormatter)
2401 {
2402 solr_string_t fbuf; /* Field name buffer to prepare field override */
2403
2404 /* Parameter value */
2405 solr_char_t *param_value = "simple";
2406 COMPAT_ARG_SIZE_T param_value_len = sizeof("simple")-1;
2407
2408 /* Field name override,f if any */
2409 solr_char_t *field_name = NULL;
2410 COMPAT_ARG_SIZE_T field_name_len = 0;
2411
2412 memset(&fbuf, 0, sizeof(solr_string_t));
2413
2414 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2415
2416 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2417
2418 RETURN_NULL();
2419 }
2420
2421 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.formatter");
2422
2423 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2424 {
2425 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2426
2427 solr_string_free(&fbuf);
2428
2429 RETURN_NULL();
2430 }
2431
2432 solr_string_free(&fbuf);
2433
2434 solr_return_solr_params_object();
2435 }
2436 /* }}} */
2437
2438 /* {{{ proto SolrQuery SolrQuery::setHighlightSimplePre(string value [, string field_override])
2439 Sets the hl.simple.pre parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightSimplePre)2440 PHP_METHOD(SolrQuery, setHighlightSimplePre)
2441 {
2442 solr_string_t fbuf; /* Field name buffer to prepare field override */
2443
2444 /* Parameter value */
2445 solr_char_t *param_value = "<em>";
2446 COMPAT_ARG_SIZE_T param_value_len = sizeof("<em>")-1;
2447
2448 /* Field name override,f if any */
2449 solr_char_t *field_name = NULL;
2450 COMPAT_ARG_SIZE_T field_name_len = 0;
2451
2452 memset(&fbuf, 0, sizeof(solr_string_t));
2453
2454 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2455
2456 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2457
2458 RETURN_NULL();
2459 }
2460
2461 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.simple.pre");
2462
2463 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2464 {
2465 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2466
2467 solr_string_free(&fbuf);
2468
2469 RETURN_NULL();
2470 }
2471
2472 solr_string_free(&fbuf);
2473
2474 solr_return_solr_params_object();
2475 }
2476 /* }}} */
2477
2478 /* {{{ proto SolrQuery SolrQuery::setHighlightSimplePost(string value [, string field_override])
2479 Sets the hl.simple.post parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightSimplePost)2480 PHP_METHOD(SolrQuery, setHighlightSimplePost)
2481 {
2482 solr_string_t fbuf; /* Field name buffer to prepare field override */
2483
2484 /* Parameter value */
2485 solr_char_t *param_value = "</em>";
2486 COMPAT_ARG_SIZE_T param_value_len = sizeof("</em>")-1;
2487
2488 /* Field name override,f if any */
2489 solr_char_t *field_name = NULL;
2490 COMPAT_ARG_SIZE_T field_name_len = 0;
2491
2492 memset(&fbuf, 0, sizeof(solr_string_t));
2493
2494 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2495
2496 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2497
2498 RETURN_NULL();
2499 }
2500
2501 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.simple.post");
2502
2503 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2504 {
2505 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2506
2507 solr_string_free(&fbuf);
2508
2509 RETURN_NULL();
2510 }
2511
2512 solr_string_free(&fbuf);
2513
2514 solr_return_solr_params_object();
2515 }
2516 /* }}} */
2517
2518 /* {{{ proto SolrQuery SolrQuery::setHighlightFragmenter(string value [, string field_override])
2519 Sets the hl.fragmenter parameter. Accepts an optional field override. */
PHP_METHOD(SolrQuery,setHighlightFragmenter)2520 PHP_METHOD(SolrQuery, setHighlightFragmenter)
2521 {
2522 solr_string_t fbuf; /* Field name buffer to prepare field override */
2523
2524 /* Parameter value */
2525 solr_char_t *param_value = NULL;
2526 COMPAT_ARG_SIZE_T param_value_len = 0;
2527
2528 /* Field name override,f if any */
2529 solr_char_t *field_name = NULL;
2530 COMPAT_ARG_SIZE_T field_name_len = 0;
2531
2532 memset(&fbuf, 0, sizeof(solr_string_t));
2533
2534 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
2535
2536 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2537
2538 RETURN_NULL();
2539 }
2540
2541 solr_query_field_override(&fbuf, field_name, field_name_len, "hl.fragmenter");
2542
2543 if (solr_set_normal_param(getThis(), fbuf.str, fbuf.len, param_value, param_value_len) == FAILURE)
2544 {
2545 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", fbuf.str, param_value);
2546
2547 solr_string_free(&fbuf);
2548
2549 RETURN_NULL();
2550 }
2551
2552 solr_string_free(&fbuf);
2553
2554 solr_return_solr_params_object();
2555 }
2556 /* }}} */
2557
2558 /* {{{ proto SolrQuery SolrQuery::setHighlightUsePhraseHighlighter(bool flag)
2559 Sets the hl.usePhraseHighlighter parameter. */
PHP_METHOD(SolrQuery,setHighlightUsePhraseHighlighter)2560 PHP_METHOD(SolrQuery, setHighlightUsePhraseHighlighter)
2561 {
2562 solr_char_t *param_name = (solr_char_t *) "hl.usePhraseHighlighter";
2563 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.usePhraseHighlighter")-1;
2564 zend_bool bool_flag = 0;
2565 solr_char_t *bool_flag_str = NULL;
2566 COMPAT_ARG_SIZE_T param_value_len = 0;
2567
2568 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
2569
2570 php_error_docref(NULL, E_WARNING, "Invalid parameter");
2571
2572 RETURN_NULL();
2573 }
2574
2575 bool_flag_str = ((bool_flag)? "true" : "false");
2576
2577 param_value_len = solr_strlen(bool_flag_str);
2578
2579 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
2580 {
2581 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
2582
2583 RETURN_NULL();
2584 }
2585
2586 solr_return_solr_params_object();
2587 }
2588 /* }}} */
2589
2590 /* {{{ proto SolrQuery SolrQuery::setHighlightHighlightMultiTerm(bool flag)
2591 Sets the hl.highlightMultiTerm parameter. */
PHP_METHOD(SolrQuery,setHighlightHighlightMultiTerm)2592 PHP_METHOD(SolrQuery, setHighlightHighlightMultiTerm)
2593 {
2594 solr_char_t *param_name = (solr_char_t *) "hl.highlightMultiTerm";
2595 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.highlightMultiTerm")-1;
2596 zend_bool bool_flag = 0;
2597 solr_char_t *bool_flag_str = NULL;
2598 COMPAT_ARG_SIZE_T param_value_len = 0;
2599
2600 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
2601
2602 php_error_docref(NULL, E_WARNING, "Invalid parameter");
2603
2604 RETURN_NULL();
2605 }
2606
2607 bool_flag_str = ((bool_flag)? "true" : "false");
2608
2609 param_value_len = solr_strlen(bool_flag_str);
2610
2611 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
2612 {
2613 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
2614
2615 RETURN_NULL();
2616 }
2617
2618 solr_return_solr_params_object();
2619 }
2620 /* }}} */
2621
2622 /* {{{ proto SolrQuery SolrQuery::setHighlightRegexSlop(string value)
2623 Sets the hl.regex.slop parameter. */
PHP_METHOD(SolrQuery,setHighlightRegexSlop)2624 PHP_METHOD(SolrQuery, setHighlightRegexSlop)
2625 {
2626 solr_char_t *param_name = (solr_char_t *) "hl.regex.slop";
2627 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.regex.slop")-1;
2628 solr_char_t *param_value = NULL;
2629 COMPAT_ARG_SIZE_T param_value_len = 0;
2630
2631 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2632
2633 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2634
2635 RETURN_NULL();
2636 }
2637
2638 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2639 {
2640 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2641
2642 RETURN_NULL();
2643 }
2644
2645 solr_return_solr_params_object();
2646 }
2647 /* }}} */
2648
2649 /* {{{ proto SolrQuery SolrQuery::setHighlightRegexPattern(string value)
2650 Sets the hl.regex.pattern parameter. */
PHP_METHOD(SolrQuery,setHighlightRegexPattern)2651 PHP_METHOD(SolrQuery, setHighlightRegexPattern)
2652 {
2653 solr_char_t *param_name = (solr_char_t *) "hl.regex.pattern";
2654 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.regex.pattern")-1;
2655 solr_char_t *param_value = NULL;
2656 COMPAT_ARG_SIZE_T param_value_len = 0;
2657
2658 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2659
2660 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2661
2662 RETURN_NULL();
2663 }
2664
2665 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2666 {
2667 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2668
2669 RETURN_NULL();
2670 }
2671
2672 solr_return_solr_params_object();
2673 }
2674 /* }}} */
2675
2676 /* {{{ proto SolrQuery SolrQuery::setHighlightRegexMaxAnalyzedChars(string value)
2677 Sets the hl.regex.maxAnalyzedChars parameter. */
PHP_METHOD(SolrQuery,setHighlightRegexMaxAnalyzedChars)2678 PHP_METHOD(SolrQuery, setHighlightRegexMaxAnalyzedChars)
2679 {
2680 solr_char_t *param_name = (solr_char_t *) "hl.regex.maxAnalyzedChars";
2681 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.regex.maxAnalyzedChars")-1;
2682 solr_char_t *param_value = NULL;
2683 COMPAT_ARG_SIZE_T param_value_len = 0;
2684
2685 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2686
2687 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2688
2689 RETURN_NULL();
2690 }
2691
2692 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2693 {
2694 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2695
2696 RETURN_NULL();
2697 }
2698
2699 solr_return_solr_params_object();
2700 }
2701 /* }}} */
2702
2703 /* }}} End of HighlightingParameters */
2704
2705 /* {{{ StatsComponent */
2706
2707 /* {{{ proto SolrQuery SolrQuery::setStats(bool flag)
2708 Sets the stats parameter. Enables or disables stats */
PHP_METHOD(SolrQuery,setStats)2709 PHP_METHOD(SolrQuery, setStats)
2710 {
2711 solr_char_t *param_name = (solr_char_t *) "stats";
2712 COMPAT_ARG_SIZE_T param_name_len = sizeof("stats")-1;
2713 zend_bool bool_flag = 0;
2714 solr_char_t *bool_flag_str = NULL;
2715 COMPAT_ARG_SIZE_T param_value_len = 0;
2716
2717 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
2718
2719 php_error_docref(NULL, E_WARNING, "Invalid parameter");
2720
2721 RETURN_NULL();
2722 }
2723
2724 bool_flag_str = ((bool_flag)? "true" : "false");
2725
2726 param_value_len = solr_strlen(bool_flag_str);
2727
2728 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
2729 {
2730 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
2731
2732 RETURN_NULL();
2733 }
2734
2735 solr_return_solr_params_object();
2736 }
2737 /* }}} */
2738
2739 /* {{{ proto SolrQuery SolrQuery::addStatsField(string value)
2740 Adds another stats.field parameter. */
PHP_METHOD(SolrQuery,addStatsField)2741 PHP_METHOD(SolrQuery, addStatsField)
2742 {
2743 solr_char_t *param_name = (solr_char_t *) "stats.field";
2744 COMPAT_ARG_SIZE_T param_name_len = sizeof("stats.field")-1;
2745 solr_char_t *param_value = NULL;
2746 COMPAT_ARG_SIZE_T param_value_len = 0;
2747
2748 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2749
2750 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2751
2752 RETURN_NULL();
2753 }
2754
2755 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2756 {
2757 php_error_docref(NULL, E_WARNING, "Error adding parameter %s=%s ", param_name, param_value);
2758
2759 RETURN_NULL();
2760 }
2761
2762 solr_return_solr_params_object();
2763 }
2764 /* }}} */
2765
2766 /* {{{ proto SolrQuery SolrQuery::addStatsFacet(string value)
2767 Adds another stats.facet parameter. */
PHP_METHOD(SolrQuery,addStatsFacet)2768 PHP_METHOD(SolrQuery, addStatsFacet)
2769 {
2770 solr_char_t *param_name = (solr_char_t *) "stats.facet";
2771 COMPAT_ARG_SIZE_T param_name_len = sizeof("stats.facet")-1;
2772 solr_char_t *param_value = NULL;
2773 COMPAT_ARG_SIZE_T param_value_len = 0;
2774
2775 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2776
2777 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2778
2779 RETURN_NULL();
2780 }
2781
2782 if (solr_add_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2783 {
2784 php_error_docref(NULL, E_WARNING, "Error adding parameter %s=%s ", param_name, param_value);
2785
2786 RETURN_NULL();
2787 }
2788
2789 solr_return_solr_params_object();
2790 }
2791 /* }}} */
2792
2793 /* }}} End of StatsComponent */
2794
2795 /* {{{ MoreLikeThis */
2796
2797 /* {{{ proto SolrQuery SolrQuery::setMlt(bool flag)
2798 Sets the mlt parameter. Enables or disables the moreLikeThis component */
PHP_METHOD(SolrQuery,setMlt)2799 PHP_METHOD(SolrQuery, setMlt)
2800 {
2801 solr_char_t *param_name = (solr_char_t *) "mlt";
2802 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt")-1;
2803 zend_bool bool_flag = 0;
2804 solr_char_t *bool_flag_str = NULL;
2805 COMPAT_ARG_SIZE_T param_value_len = 0;
2806
2807 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
2808
2809 php_error_docref(NULL, E_WARNING, "Invalid parameter");
2810
2811 RETURN_NULL();
2812 }
2813
2814 bool_flag_str = ((bool_flag)? "true" : "false");
2815
2816 param_value_len = solr_strlen(bool_flag_str);
2817
2818 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
2819 {
2820 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
2821
2822 RETURN_NULL();
2823 }
2824
2825 solr_return_solr_params_object();
2826 }
2827 /* }}} */
2828
2829 /* {{{ proto SolrQuery SolrQuery::setMltCount(string value)
2830 Sets the mlt.count parameter. */
PHP_METHOD(SolrQuery,setMltCount)2831 PHP_METHOD(SolrQuery, setMltCount)
2832 {
2833 solr_char_t *param_name = (solr_char_t *) "mlt.count";
2834 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.count")-1;
2835 solr_char_t *param_value = NULL;
2836 COMPAT_ARG_SIZE_T param_value_len = 0;
2837
2838 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2839
2840 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2841
2842 RETURN_NULL();
2843 }
2844
2845 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2846 {
2847 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2848
2849 RETURN_NULL();
2850 }
2851
2852 solr_return_solr_params_object();
2853 }
2854 /* }}} */
2855
2856 /* {{{ proto SolrQuery SolrQuery::addMltField(string field)
2857 Adds another field name to the mlt.fl parameter. */
PHP_METHOD(SolrQuery,addMltField)2858 PHP_METHOD(SolrQuery, addMltField)
2859 {
2860 solr_char_t *list_param_name = (solr_char_t *) "mlt.fl";
2861 COMPAT_ARG_SIZE_T list_param_name_len = sizeof("mlt.fl")-1;
2862 solr_char_t *list_param_value = NULL;
2863 COMPAT_ARG_SIZE_T list_param_value_len = 0;
2864
2865 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &list_param_value, &list_param_value_len) == FAILURE) {
2866
2867 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2868
2869 RETURN_NULL();
2870 }
2871
2872 if (solr_add_simple_list_param(getThis(), list_param_name, list_param_name_len, list_param_value, list_param_value_len) == FAILURE)
2873 {
2874 php_error_docref(NULL, E_WARNING, "Unable to add param value %s to %s list ", list_param_value, list_param_name);
2875
2876 RETURN_NULL();
2877 }
2878
2879 solr_return_solr_params_object();
2880 }
2881 /* }}} */
2882
2883 /* {{{ proto SolrQuery SolrQuery::addMltQueryField(string value, string boost)
2884 Adds another query field and boost value to the mlt.qf parameter. */
PHP_METHOD(SolrQuery,addMltQueryField)2885 PHP_METHOD(SolrQuery, addMltQueryField)
2886 {
2887 solr_char_t *param_name = (solr_char_t *) "mlt.qf";
2888 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.qf")-1;
2889 solr_char_t *query_field = NULL;
2890 COMPAT_ARG_SIZE_T query_field_length = 0;
2891 solr_char_t *boost_value = "1.0";
2892 COMPAT_ARG_SIZE_T boost_value_length = sizeof("1.0");
2893
2894 /* TODO: make boost optional parameter. */
2895 /* If boost is not sent, then the index time boost is used */
2896 /* This will involve re-doing all the arg_list functions to allow optional args. */
2897 /* Temporary solution is to use SolrQuery::add("mlt.qf", "value"). This should be documented. */
2898
2899 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &query_field, &query_field_length, &boost_value, &boost_value_length) == FAILURE) {
2900
2901 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2902
2903 RETURN_NULL();
2904 }
2905
2906 if (solr_add_arg_list_param(getThis(), param_name, param_name_len, query_field, query_field_length, boost_value, boost_value_length, ' ', '^') == FAILURE)
2907 {
2908 RETURN_NULL();
2909 }
2910
2911 solr_return_solr_params_object();
2912 }
2913 /* }}} */
2914
2915 /* {{{ proto SolrQuery SolrQuery::setMltMinTermFrequency(string value)
2916 Sets the mlt.mintf parameter. */
PHP_METHOD(SolrQuery,setMltMinTermFrequency)2917 PHP_METHOD(SolrQuery, setMltMinTermFrequency)
2918 {
2919 solr_char_t *param_name = (solr_char_t *) "mlt.mintf";
2920 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.mintf")-1;
2921 solr_char_t *param_value = NULL;
2922 COMPAT_ARG_SIZE_T param_value_len = 0;
2923
2924 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2925
2926 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2927
2928 RETURN_NULL();
2929 }
2930
2931 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2932 {
2933 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2934
2935 RETURN_NULL();
2936 }
2937
2938 solr_return_solr_params_object();
2939 }
2940 /* }}} */
2941
2942 /* {{{ proto SolrQuery SolrQuery::setMltMinDocFrequency(string value)
2943 Sets the mlt.mindf parameter. */
PHP_METHOD(SolrQuery,setMltMinDocFrequency)2944 PHP_METHOD(SolrQuery, setMltMinDocFrequency)
2945 {
2946 solr_char_t *param_name = (solr_char_t *) "mlt.mindf";
2947 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.mindf")-1;
2948 solr_char_t *param_value = NULL;
2949 COMPAT_ARG_SIZE_T param_value_len = 0;
2950
2951 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2952
2953 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2954
2955 RETURN_NULL();
2956 }
2957
2958 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2959 {
2960 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2961
2962 RETURN_NULL();
2963 }
2964
2965 solr_return_solr_params_object();
2966 }
2967 /* }}} */
2968
2969 /* {{{ proto SolrQuery SolrQuery::setMltMinWordLength(string value)
2970 Sets the mlt.minwl parameter. */
PHP_METHOD(SolrQuery,setMltMinWordLength)2971 PHP_METHOD(SolrQuery, setMltMinWordLength)
2972 {
2973 solr_char_t *param_name = (solr_char_t *) "mlt.minwl";
2974 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.minwl")-1;
2975 solr_char_t *param_value = NULL;
2976 COMPAT_ARG_SIZE_T param_value_len = 0;
2977
2978 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
2979
2980 php_error_docref(NULL, E_WARNING, "Invalid parameters");
2981
2982 RETURN_NULL();
2983 }
2984
2985 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
2986 {
2987 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
2988
2989 RETURN_NULL();
2990 }
2991
2992 solr_return_solr_params_object();
2993 }
2994 /* }}} */
2995
2996 /* {{{ proto SolrQuery SolrQuery::setMltMaxWordLength(string value)
2997 Sets the mlt.maxwl parameter. */
PHP_METHOD(SolrQuery,setMltMaxWordLength)2998 PHP_METHOD(SolrQuery, setMltMaxWordLength)
2999 {
3000 solr_char_t *param_name = (solr_char_t *) "mlt.maxwl";
3001 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.maxwl")-1;
3002 solr_char_t *param_value = NULL;
3003 COMPAT_ARG_SIZE_T param_value_len = 0;
3004
3005 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3006
3007 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3008
3009 RETURN_NULL();
3010 }
3011
3012 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3013 {
3014 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3015
3016 RETURN_NULL();
3017 }
3018
3019 solr_return_solr_params_object();
3020 }
3021 /* }}} */
3022
3023 /* {{{ proto SolrQuery SolrQuery::setMltMaxNumTokens(string value)
3024 Sets the mlt.maxntp parameter. */
PHP_METHOD(SolrQuery,setMltMaxNumTokens)3025 PHP_METHOD(SolrQuery, setMltMaxNumTokens)
3026 {
3027 solr_char_t *param_name = (solr_char_t *) "mlt.maxntp";
3028 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.maxntp")-1;
3029 solr_char_t *param_value = NULL;
3030 COMPAT_ARG_SIZE_T param_value_len = 0;
3031
3032 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3033
3034 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3035
3036 RETURN_NULL();
3037 }
3038
3039 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3040 {
3041 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3042
3043 RETURN_NULL();
3044 }
3045
3046 solr_return_solr_params_object();
3047 }
3048 /* }}} */
3049
3050 /* {{{ proto SolrQuery SolrQuery::setMltMaxNumQueryTerms(string value)
3051 Sets the mlt.maxqt parameter. */
PHP_METHOD(SolrQuery,setMltMaxNumQueryTerms)3052 PHP_METHOD(SolrQuery, setMltMaxNumQueryTerms)
3053 {
3054 solr_char_t *param_name = (solr_char_t *) "mlt.maxqt";
3055 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.maxqt")-1;
3056 solr_char_t *param_value = NULL;
3057 COMPAT_ARG_SIZE_T param_value_len = 0;
3058
3059 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3060
3061 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3062
3063 RETURN_NULL();
3064 }
3065
3066 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3067 {
3068 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3069
3070 RETURN_NULL();
3071 }
3072
3073 solr_return_solr_params_object();
3074 }
3075 /* }}} */
3076
3077 /* {{{ proto SolrQuery SolrQuery::setMltBoost(bool flag)
3078 Sets the mlt.boost parameter. */
PHP_METHOD(SolrQuery,setMltBoost)3079 PHP_METHOD(SolrQuery, setMltBoost)
3080 {
3081 solr_char_t *param_name = (solr_char_t *) "mlt.boost";
3082 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.boost")-1;
3083 zend_bool bool_flag = 0;
3084 solr_char_t *bool_flag_str = NULL;
3085 COMPAT_ARG_SIZE_T param_value_len = 0;
3086
3087 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
3088
3089 php_error_docref(NULL, E_WARNING, "Invalid parameter");
3090
3091 RETURN_NULL();
3092 }
3093
3094 bool_flag_str = ((bool_flag)? "true" : "false");
3095
3096 param_value_len = solr_strlen(bool_flag_str);
3097
3098 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
3099 {
3100 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
3101
3102 RETURN_NULL();
3103 }
3104
3105 solr_return_solr_params_object();
3106 }
3107 /* }}} */
3108
3109 /* }}} End of MoreLikeThis */
3110
3111 /* {{{ TermsComponent */
3112
3113 /* {{{ proto SolrQuery SolrQuery::setTerms(bool flag)
3114 Sets the terms parameter. This flag enables or disables the TermsComponent */
PHP_METHOD(SolrQuery,setTerms)3115 PHP_METHOD(SolrQuery, setTerms)
3116 {
3117 solr_char_t *param_name = (solr_char_t *) "terms";
3118 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms")-1;
3119 zend_bool bool_flag = 0;
3120 solr_char_t *bool_flag_str = NULL;
3121 COMPAT_ARG_SIZE_T param_value_len = 0;
3122
3123 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
3124
3125 php_error_docref(NULL, E_WARNING, "Invalid parameter");
3126
3127 RETURN_NULL();
3128 }
3129
3130 bool_flag_str = ((bool_flag)? "true" : "false");
3131
3132 param_value_len = solr_strlen(bool_flag_str);
3133
3134 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
3135 {
3136 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
3137
3138 RETURN_NULL();
3139 }
3140
3141 solr_return_solr_params_object();
3142 }
3143 /* }}} */
3144
3145 /* {{{ proto SolrQuery SolrQuery::setTermsField(string field)
3146 Sets the terms.fl parameter. */
PHP_METHOD(SolrQuery,setTermsField)3147 PHP_METHOD(SolrQuery, setTermsField)
3148 {
3149 solr_char_t *param_name = (solr_char_t *) "terms.fl";
3150 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.fl")-1;
3151 solr_char_t *param_value = NULL;
3152 COMPAT_ARG_SIZE_T param_value_len = 0;
3153
3154 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3155
3156 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3157
3158 RETURN_NULL();
3159 }
3160
3161 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3162 {
3163 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3164
3165 RETURN_NULL();
3166 }
3167
3168 solr_return_solr_params_object();
3169 }
3170 /* }}} */
3171
3172 /* {{{ proto SolrQuery SolrQuery::setTermsLowerBound(string value)
3173 Sets the terms.lower parameter. */
PHP_METHOD(SolrQuery,setTermsLowerBound)3174 PHP_METHOD(SolrQuery, setTermsLowerBound)
3175 {
3176 solr_char_t *param_name = (solr_char_t *) "terms.lower";
3177 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.lower")-1;
3178
3179 solr_char_t *param_value = NULL;
3180 COMPAT_ARG_SIZE_T param_value_len = 0;
3181
3182 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3183
3184 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3185
3186 RETURN_NULL();
3187 }
3188
3189 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3190 {
3191 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3192
3193 RETURN_NULL();
3194 }
3195
3196 solr_return_solr_params_object();
3197 }
3198 /* }}} */
3199
3200 /* {{{ proto SolrQuery SolrQuery::setTermsUpperBound(string value)
3201 Sets the terms.upper parameter. */
PHP_METHOD(SolrQuery,setTermsUpperBound)3202 PHP_METHOD(SolrQuery, setTermsUpperBound)
3203 {
3204 solr_char_t *param_name = (solr_char_t *) "terms.upper";
3205 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.upper")-1;
3206
3207 solr_char_t *param_value = NULL;
3208 COMPAT_ARG_SIZE_T param_value_len = 0;
3209
3210 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3211
3212 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3213
3214 RETURN_NULL();
3215 }
3216
3217 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3218 {
3219 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3220
3221 RETURN_NULL();
3222 }
3223
3224 solr_return_solr_params_object();
3225 }
3226 /* }}} */
3227
3228 /* {{{ proto SolrQuery SolrQuery::setTermsIncludeLowerBound(string value)
3229 Sets the terms.lower.incl parameter. */
PHP_METHOD(SolrQuery,setTermsIncludeLowerBound)3230 PHP_METHOD(SolrQuery, setTermsIncludeLowerBound)
3231 {
3232 solr_char_t *param_name = (solr_char_t *) "terms.lower.incl";
3233 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.lower.incl")-1;
3234 zend_bool bool_flag = 0;
3235 solr_char_t *bool_flag_str = NULL;
3236 COMPAT_ARG_SIZE_T param_value_len = 0;
3237
3238 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
3239
3240 php_error_docref(NULL, E_WARNING, "Invalid parameter");
3241
3242 RETURN_NULL();
3243 }
3244
3245 bool_flag_str = ((bool_flag)? "true" : "false");
3246
3247 param_value_len = solr_strlen(bool_flag_str);
3248
3249 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
3250 {
3251 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
3252
3253 RETURN_NULL();
3254 }
3255
3256 solr_return_solr_params_object();
3257 }
3258 /* }}} */
3259
3260 /* {{{ proto SolrQuery SolrQuery::setTermsIncludeUpperBound(string value)
3261 Sets the terms.upper.incl parameter. */
PHP_METHOD(SolrQuery,setTermsIncludeUpperBound)3262 PHP_METHOD(SolrQuery, setTermsIncludeUpperBound)
3263 {
3264 solr_char_t *param_name = (solr_char_t *) "terms.upper.incl";
3265 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.upper.incl")-1;
3266 zend_bool bool_flag = 0;
3267 solr_char_t *bool_flag_str = NULL;
3268 COMPAT_ARG_SIZE_T param_value_len = 0;
3269
3270 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
3271
3272 php_error_docref(NULL, E_WARNING, "Invalid parameter");
3273
3274 RETURN_NULL();
3275 }
3276
3277 bool_flag_str = ((bool_flag)? "true" : "false");
3278
3279 param_value_len = solr_strlen(bool_flag_str);
3280
3281 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
3282 {
3283 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
3284
3285 RETURN_NULL();
3286 }
3287
3288 solr_return_solr_params_object();
3289 }
3290 /* }}} */
3291
3292 /* {{{ proto SolrQuery SolrQuery::setTermsMinCount(string value)
3293 Sets the terms.mincount parameter. */
PHP_METHOD(SolrQuery,setTermsMinCount)3294 PHP_METHOD(SolrQuery, setTermsMinCount)
3295 {
3296 solr_char_t *param_name = (solr_char_t *) "terms.mincount";
3297 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.mincount")-1;
3298
3299 solr_char_t *param_value = NULL;
3300 COMPAT_ARG_SIZE_T param_value_len = 0;
3301
3302 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3303
3304 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3305
3306 RETURN_NULL();
3307 }
3308
3309 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3310 {
3311 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3312
3313 RETURN_NULL();
3314 }
3315
3316 solr_return_solr_params_object();
3317 }
3318 /* }}} */
3319
3320 /* {{{ proto SolrQuery SolrQuery::setTermsMaxCount(string value)
3321 Sets the terms.maxcount parameter. */
PHP_METHOD(SolrQuery,setTermsMaxCount)3322 PHP_METHOD(SolrQuery, setTermsMaxCount)
3323 {
3324 solr_char_t *param_name = (solr_char_t *) "terms.maxcount";
3325 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.maxcount")-1;
3326
3327 solr_char_t *param_value = NULL;
3328 COMPAT_ARG_SIZE_T param_value_len = 0;
3329
3330 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3331
3332 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3333
3334 RETURN_NULL();
3335 }
3336
3337 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3338 {
3339 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3340
3341 RETURN_NULL();
3342 }
3343
3344 solr_return_solr_params_object();
3345 }
3346 /* }}} */
3347
3348 /* {{{ proto SolrQuery SolrQuery::setTermsPrefix(string value)
3349 Sets the terms.prefix parameter. */
PHP_METHOD(SolrQuery,setTermsPrefix)3350 PHP_METHOD(SolrQuery, setTermsPrefix)
3351 {
3352 solr_char_t *param_name = (solr_char_t *) "terms.prefix";
3353 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.prefix")-1;
3354
3355 solr_char_t *param_value = NULL;
3356 COMPAT_ARG_SIZE_T param_value_len = 0;
3357
3358 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3359
3360 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3361
3362 RETURN_NULL();
3363 }
3364
3365 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3366 {
3367 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3368
3369 RETURN_NULL();
3370 }
3371
3372 solr_return_solr_params_object();
3373 }
3374 /* }}} */
3375
3376 /* {{{ proto SolrQuery SolrQuery::setTermsLimit(string value)
3377 Sets the terms.limit parameter. */
PHP_METHOD(SolrQuery,setTermsLimit)3378 PHP_METHOD(SolrQuery, setTermsLimit)
3379 {
3380 solr_char_t *param_name = (solr_char_t *) "terms.limit";
3381 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.limit")-1;
3382 solr_char_t *param_value = NULL;
3383 COMPAT_ARG_SIZE_T param_value_len = 0;
3384
3385 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3386
3387 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3388
3389 RETURN_NULL();
3390 }
3391
3392 if (solr_set_normal_param(getThis(), param_name, param_name_len, param_value, param_value_len) == FAILURE)
3393 {
3394 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s", param_name, param_value);
3395
3396 RETURN_NULL();
3397 }
3398
3399 solr_return_solr_params_object();
3400 }
3401 /* }}} */
3402
3403 /* {{{ proto SolrQuery SolrQuery::setTermsReturnRaw(bool flag)
3404 Sets the terms.raw parameter. */
PHP_METHOD(SolrQuery,setTermsReturnRaw)3405 PHP_METHOD(SolrQuery, setTermsReturnRaw)
3406 {
3407 solr_char_t *param_name = (solr_char_t *) "terms.raw";
3408 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.raw")-1;
3409 zend_bool bool_flag = 0;
3410 solr_char_t *bool_flag_str = NULL;
3411 COMPAT_ARG_SIZE_T param_value_len = 0;
3412
3413 if (zend_parse_parameters(ZEND_NUM_ARGS(), "b", &bool_flag) == FAILURE) {
3414
3415 php_error_docref(NULL, E_WARNING, "Invalid parameter");
3416
3417 RETURN_NULL();
3418 }
3419
3420 bool_flag_str = ((bool_flag)? "true" : "false");
3421
3422 param_value_len = solr_strlen(bool_flag_str);
3423
3424 if (solr_set_normal_param(getThis(), param_name, param_name_len, bool_flag_str, param_value_len) == FAILURE)
3425 {
3426 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, bool_flag_str);
3427
3428 RETURN_NULL();
3429 }
3430
3431 solr_return_solr_params_object();
3432 }
3433 /* }}} */
3434
3435 /* {{{ proto SolrQuery SolrQuery::setTermsSort(int sort)
3436 Sets the terms.sort parameter. */
PHP_METHOD(SolrQuery,setTermsSort)3437 PHP_METHOD(SolrQuery, setTermsSort)
3438 {
3439 solr_char_t *param_name = (solr_char_t *) "terms.sort";
3440 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.sort")-1;
3441 long int sort_type = 0L;
3442 solr_char_t *sort_type_str = NULL;
3443 COMPAT_ARG_SIZE_T param_value_len = 0;
3444
3445 if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &sort_type) == FAILURE) {
3446
3447 php_error_docref(NULL, E_WARNING, "Invalid parameter");
3448
3449 RETURN_NULL();
3450 }
3451
3452 sort_type_str = ((sort_type)? "count" : "index");
3453 param_value_len = solr_strlen(sort_type_str);
3454
3455 if (solr_set_normal_param(getThis(), param_name, param_name_len, sort_type_str, param_value_len) == FAILURE)
3456 {
3457 php_error_docref(NULL, E_WARNING, "Error setting parameter %s=%s ", param_name, sort_type_str);
3458
3459 RETURN_NULL();
3460 }
3461
3462 solr_return_solr_params_object();
3463 }
3464 /* }}} */
3465
3466 /* }}} End of TermsComponent */
3467
3468 /* {{{ Value removal methods */
3469
3470 /* {{{ proto SolrQuery SolrQuery::removeField(string fl)
3471 Removes a field from the fl parameter */
PHP_METHOD(SolrQuery,removeField)3472 PHP_METHOD(SolrQuery, removeField)
3473 {
3474 solr_char_t *pname = (solr_char_t *) "fl";
3475 int pname_length = sizeof("fl")-1;
3476 solr_char_t *param_value = NULL;
3477 COMPAT_ARG_SIZE_T param_value_len = 0;
3478
3479 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3480
3481 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3482
3483 RETURN_NULL();
3484 }
3485
3486 solr_delete_simple_list_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3487
3488 solr_return_solr_params_object();
3489 }
3490 /* }}} */
3491
3492 /* {{{ proto SolrQuery SolrQuery::removeSortField(string fl)
3493 Removes a sort field from the sort parameter. */
PHP_METHOD(SolrQuery,removeSortField)3494 PHP_METHOD(SolrQuery, removeSortField)
3495 {
3496 solr_char_t *pname = (solr_char_t *) "sort";
3497 int pname_length = sizeof("sort")-1;
3498
3499 solr_char_t *param_value = NULL;
3500 COMPAT_ARG_SIZE_T param_value_len = 0;
3501
3502 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3503
3504 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3505
3506 RETURN_NULL();
3507 }
3508
3509 solr_delete_arg_list_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3510
3511 solr_return_solr_params_object();
3512 }
3513 /* }}} */
3514
3515 /* {{{ proto SolrQuery SolrQuery::removeFilterQuery(string fq)
3516 Removes one of the fq parameter. */
PHP_METHOD(SolrQuery,removeFilterQuery)3517 PHP_METHOD(SolrQuery, removeFilterQuery)
3518 {
3519 solr_char_t *pname = (solr_char_t *) "fq";
3520 int pname_length = sizeof("fq")-1;
3521
3522 solr_char_t *param_value = NULL;
3523 COMPAT_ARG_SIZE_T param_value_len = 0;
3524
3525 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3526
3527 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3528
3529 RETURN_NULL();
3530 }
3531
3532 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3533
3534 solr_return_solr_params_object();
3535 }
3536 /* }}} */
3537
3538 /* {{{ proto SolrQuery SolrQuery::removeFacetField(string field)
3539 Removes one of fields from the facet.field parameter. */
PHP_METHOD(SolrQuery,removeFacetField)3540 PHP_METHOD(SolrQuery, removeFacetField)
3541 {
3542 solr_char_t *pname = (solr_char_t *) "facet.field";
3543 int pname_length = sizeof("facet.field")-1;
3544
3545 solr_char_t *param_value = NULL;
3546 COMPAT_ARG_SIZE_T param_value_len = 0;
3547
3548 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3549
3550 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3551
3552 RETURN_NULL();
3553 }
3554
3555 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3556
3557 solr_return_solr_params_object();
3558 }
3559 /* }}} */
3560
3561 /* {{{ proto SolrQuery SolrQuery::removeFacetQuery(string facet_query)
3562 Removes one of the facet.query parameters. */
PHP_METHOD(SolrQuery,removeFacetQuery)3563 PHP_METHOD(SolrQuery, removeFacetQuery)
3564 {
3565 solr_char_t *pname = (solr_char_t *) "facet.query";
3566 int pname_length = sizeof("facet.query")-1;
3567
3568 solr_char_t *param_value = NULL;
3569 COMPAT_ARG_SIZE_T param_value_len = 0;
3570
3571 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3572
3573 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3574
3575 RETURN_NULL();
3576 }
3577
3578 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3579
3580 solr_return_solr_params_object();
3581 }
3582 /* }}} */
3583
3584 /* {{{ proto SolrQuery SolrQuery::removeFacetDateField(string date_field)
3585 Removes one of the facet.date parameters. */
PHP_METHOD(SolrQuery,removeFacetDateField)3586 PHP_METHOD(SolrQuery, removeFacetDateField)
3587 {
3588 solr_char_t *pname = (solr_char_t *) "facet.date";
3589 int pname_length = sizeof("facet.date")-1;
3590
3591 solr_char_t *param_value = NULL;
3592 COMPAT_ARG_SIZE_T param_value_len = 0;
3593
3594 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3595
3596 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3597
3598 RETURN_NULL();
3599 }
3600
3601 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3602
3603 solr_return_solr_params_object();
3604 }
3605 /* }}} */
3606
3607 /* {{{ proto SolrQuery SolrQuery::removeFacetDateOther(string value [, string field_override])
3608 Removes one of the facet.date.other parameters. Also accepts an optional field override. */
PHP_METHOD(SolrQuery,removeFacetDateOther)3609 PHP_METHOD(SolrQuery, removeFacetDateOther)
3610 {
3611 solr_string_t fbuf; /* Field name buffer to prepare field override */
3612
3613 /* Parameter value */
3614 solr_char_t *param_value = NULL;
3615 COMPAT_ARG_SIZE_T param_value_len = 0;
3616
3617 /* Field name override,f if any */
3618 solr_char_t *field_name = NULL;
3619 COMPAT_ARG_SIZE_T field_name_len = 0;
3620
3621 memset(&fbuf, 0, sizeof(solr_string_t));
3622
3623 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|s", ¶m_value, ¶m_value_len, &field_name, &field_name_len) == FAILURE) {
3624
3625 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3626
3627 RETURN_NULL();
3628 }
3629
3630 solr_query_field_override(&fbuf, field_name, field_name_len, "facet.date.other");
3631
3632 solr_delete_normal_param_value(getThis(), fbuf.str, fbuf.len, param_value, param_value_len);
3633
3634 solr_string_free(&fbuf);
3635
3636 solr_return_solr_params_object();
3637 }
3638 /* }}} */
3639
3640 /* {{{ proto SolrQuery SolrQuery::removeHighlightField(string field)
3641 Removes one of the fields from the hl.fl parameter. */
PHP_METHOD(SolrQuery,removeHighlightField)3642 PHP_METHOD(SolrQuery, removeHighlightField)
3643 {
3644 solr_char_t *pname = (solr_char_t *) "hl.fl";
3645 int pname_length = sizeof("hl.fl")-1;
3646 solr_char_t *param_value = NULL;
3647 COMPAT_ARG_SIZE_T param_value_len = 0;
3648
3649 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3650
3651 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3652
3653 RETURN_NULL();
3654 }
3655
3656 solr_delete_simple_list_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3657
3658 solr_return_solr_params_object();
3659 }
3660 /* }}} */
3661
3662 /* {{{ proto SolrQuery SolrQuery::removeStatsField(string field)
3663 Removes one of the stats.field parameters. */
PHP_METHOD(SolrQuery,removeStatsField)3664 PHP_METHOD(SolrQuery, removeStatsField)
3665 {
3666 solr_char_t *pname = (solr_char_t *) "stats.field";
3667 int pname_length = sizeof("stats.field")-1;
3668 solr_char_t *param_value = NULL;
3669 COMPAT_ARG_SIZE_T param_value_len = 0;
3670
3671 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3672
3673 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3674
3675 RETURN_NULL();
3676 }
3677
3678 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3679
3680 solr_return_solr_params_object();
3681 }
3682 /* }}} */
3683
3684 /* {{{ proto SolrQuery SolrQuery::removeStatsFacet(string value)
3685 Removes one of the stats.facet parameters. */
PHP_METHOD(SolrQuery,removeStatsFacet)3686 PHP_METHOD(SolrQuery, removeStatsFacet)
3687 {
3688 solr_char_t *pname = (solr_char_t *) "stats.facet";
3689 int pname_length = sizeof("stats.facet")-1;
3690 solr_char_t *param_value = NULL;
3691 COMPAT_ARG_SIZE_T param_value_len = 0;
3692
3693 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3694
3695 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3696
3697 RETURN_NULL();
3698 }
3699
3700 solr_delete_normal_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3701
3702 solr_return_solr_params_object();
3703 }
3704 /* }}} */
3705
3706 /* {{{ proto SolrQuery SolrQuery::removeMltField(string field)
3707 Removes one of the fields from the mlt.fl parameter. */
PHP_METHOD(SolrQuery,removeMltField)3708 PHP_METHOD(SolrQuery, removeMltField)
3709 {
3710 solr_char_t *pname = (solr_char_t *) "mlt.fl";
3711 int pname_length = sizeof("mlt.fl")-1;
3712 solr_char_t *param_value = NULL;
3713 COMPAT_ARG_SIZE_T param_value_len = 0;
3714
3715 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3716
3717 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3718
3719 RETURN_NULL();
3720 }
3721
3722 solr_delete_simple_list_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3723
3724 solr_return_solr_params_object();
3725 }
3726 /* }}} */
3727
3728 /* {{{ proto SolrQuery SolrQuery::removeMltQueryField(string field)
3729 Removes one of the values from the mlt.qf parameter. */
PHP_METHOD(SolrQuery,removeMltQueryField)3730 PHP_METHOD(SolrQuery, removeMltQueryField)
3731 {
3732 solr_char_t *pname = (solr_char_t *) "mlt.qf";
3733 int pname_length = sizeof("mlt.qf")-1;
3734 solr_char_t *param_value = NULL;
3735 COMPAT_ARG_SIZE_T param_value_len = 0;
3736
3737 if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", ¶m_value, ¶m_value_len) == FAILURE) {
3738
3739 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3740
3741 RETURN_NULL();
3742 }
3743
3744 solr_delete_arg_list_param_value(getThis(), pname, pname_length, param_value, param_value_len);
3745
3746 solr_return_solr_params_object();
3747 }
3748 /* }}} */
3749
3750 /* }}} End of Value removal methods */
3751
3752 /* {{{ Begin getter methods */
3753
3754 /* {{{ proto string SolrQuery::getQuery()
3755 Returns the query */
PHP_METHOD(SolrQuery,getQuery)3756 PHP_METHOD(SolrQuery, getQuery)
3757 {
3758 solr_char_t *param_name = (solr_char_t *) "q";
3759 COMPAT_ARG_SIZE_T param_name_len = sizeof("q")-1;
3760 solr_param_t *solr_param = NULL;
3761
3762 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3763
3764 RETURN_NULL();
3765 }
3766
3767 solr_normal_param_value_display_string(solr_param, return_value);
3768 }
3769 /* }}} */
3770
3771 /* {{{ proto int SolrQuery::getStart()
3772 Returns the start parameter */
PHP_METHOD(SolrQuery,getStart)3773 PHP_METHOD(SolrQuery, getStart)
3774 {
3775 solr_char_t *param_name = (solr_char_t *) "start";
3776 COMPAT_ARG_SIZE_T param_name_len = sizeof("start")-1;
3777 solr_param_t *solr_param = NULL;
3778
3779 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3780
3781 RETURN_NULL();
3782 }
3783
3784 solr_normal_param_value_display_integer(solr_param, return_value);
3785 }
3786 /* }}} */
3787
3788 /* {{{ proto int SolrQuery::getRows()
3789 Returns the rows parameter */
PHP_METHOD(SolrQuery,getRows)3790 PHP_METHOD(SolrQuery, getRows)
3791 {
3792 solr_char_t *param_name = (solr_char_t *) "rows";
3793 COMPAT_ARG_SIZE_T param_name_len = sizeof("rows")-1;
3794 solr_param_t *solr_param = NULL;
3795
3796 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3797
3798 RETURN_NULL();
3799 }
3800
3801 solr_normal_param_value_display_integer(solr_param, return_value);
3802 }
3803 /* }}} */
3804
3805 /* {{{ proto array SolrQuery::getFields()
3806 Returns the fields */
PHP_METHOD(SolrQuery,getFields)3807 PHP_METHOD(SolrQuery, getFields)
3808 {
3809 solr_char_t *param_name = (solr_char_t *) "fl";
3810 COMPAT_ARG_SIZE_T param_name_len = sizeof("fl")-1;
3811 solr_param_t *solr_param = NULL;
3812
3813 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3814
3815 RETURN_NULL();
3816 }
3817
3818 array_init(return_value);
3819
3820 solr_simple_list_param_value_display(solr_param, return_value);
3821 }
3822 /* }}} */
3823
3824 /* {{{ proto array SolrQuery::getSortFields()
3825 Returns all the sort fields */
PHP_METHOD(SolrQuery,getSortFields)3826 PHP_METHOD(SolrQuery, getSortFields)
3827 {
3828 solr_char_t *param_name = (solr_char_t *) "sort";
3829 COMPAT_ARG_SIZE_T param_name_len = sizeof("sort")-1;
3830 solr_param_t *solr_param = NULL;
3831
3832 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3833
3834 RETURN_NULL();
3835 }
3836
3837 array_init(return_value);
3838
3839 solr_arg_list_param_value_display(solr_param, return_value);
3840
3841 }
3842 /* }}} */
3843
3844 /* {{{ proto string SolrQuery::getFilterQueries()
3845 Returns all the filter queries */
PHP_METHOD(SolrQuery,getFilterQueries)3846 PHP_METHOD(SolrQuery, getFilterQueries)
3847 {
3848 solr_char_t *param_name = (solr_char_t *) "fq";
3849 COMPAT_ARG_SIZE_T param_name_len = sizeof("fq")-1;
3850 solr_param_t *solr_param = NULL;
3851
3852 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3853
3854 RETURN_NULL();
3855 }
3856
3857 array_init(return_value);
3858
3859 solr_normal_param_value_display(solr_param, return_value);
3860 }
3861 /* }}} */
3862
3863 /* {{{ proto string SolrQuery::getTimeAllowed()
3864 Returns the maximum time in milliseconds allowed for the search query */
PHP_METHOD(SolrQuery,getTimeAllowed)3865 PHP_METHOD(SolrQuery, getTimeAllowed)
3866 {
3867 solr_char_t *param_name = (solr_char_t *) "timeAllowed";
3868 COMPAT_ARG_SIZE_T param_name_len = sizeof("timeAllowed")-1;
3869 solr_param_t *solr_param = NULL;
3870
3871 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3872
3873 RETURN_NULL();
3874 }
3875
3876 solr_normal_param_value_display_integer(solr_param, return_value);
3877 }
3878 /* }}} */
3879
3880 /* {{{ proto bool SolrQuery::getFacet()
3881 Returns true is faceting is enabled */
PHP_METHOD(SolrQuery,getFacet)3882 PHP_METHOD(SolrQuery, getFacet)
3883 {
3884 solr_char_t *param_name = (solr_char_t *) "facet";
3885 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet")-1;
3886 solr_param_t *solr_param = NULL;
3887
3888 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3889
3890 RETURN_NULL();
3891 }
3892
3893 solr_normal_param_value_display_boolean(solr_param, return_value);
3894 }
3895 /* }}} */
3896
3897 /* {{{ proto string SolrQuery::getFacetFields()
3898 Returns all the facet fields */
PHP_METHOD(SolrQuery,getFacetFields)3899 PHP_METHOD(SolrQuery, getFacetFields)
3900 {
3901 solr_char_t *param_name = (solr_char_t *) "facet.field";
3902 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet.field")-1;
3903 solr_param_t *solr_param = NULL;
3904
3905 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3906
3907 RETURN_NULL();
3908 }
3909
3910 array_init(return_value);
3911
3912 solr_normal_param_value_display(solr_param, return_value);
3913 }
3914 /* }}} */
3915
3916 /* {{{ proto string SolrQuery::getFacetQueries()
3917 Returns all the facet queries */
PHP_METHOD(SolrQuery,getFacetQueries)3918 PHP_METHOD(SolrQuery, getFacetQueries)
3919 {
3920 solr_char_t *param_name = (solr_char_t *) "facet.query";
3921 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet.query")-1;
3922 solr_param_t *solr_param = NULL;
3923
3924 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
3925
3926 RETURN_NULL();
3927 }
3928
3929 array_init(return_value);
3930
3931 solr_normal_param_value_display(solr_param, return_value);
3932 }
3933 /* }}} */
3934
3935 /* {{{ proto string SolrQuery::getFacetPrefix([string field_override])
3936 Returns the prefix for the facet */
PHP_METHOD(SolrQuery,getFacetPrefix)3937 PHP_METHOD(SolrQuery, getFacetPrefix)
3938 {
3939 solr_param_t *solr_param = NULL;
3940
3941 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
3942
3943 /* Field name override, if any */
3944 solr_char_t *field_name = NULL;
3945 COMPAT_ARG_SIZE_T field_name_len = 0;
3946
3947 /* Set if the parameter was found in the HashTable and off otherwise */
3948 zend_bool param_is_set = 1;
3949
3950 memset(&field_override_buffer, 0, sizeof(solr_string_t));
3951
3952 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
3953
3954 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3955
3956 RETURN_NULL();
3957 }
3958
3959 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.prefix");
3960
3961 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
3962
3963 param_is_set = 0;
3964 }
3965
3966 solr_string_free(&field_override_buffer);
3967
3968 if (param_is_set) {
3969
3970 solr_normal_param_value_display_string(solr_param, return_value);
3971
3972 return;
3973 }
3974
3975 RETURN_NULL();
3976 }
3977 /* }}} */
3978
3979 /* {{{ proto int SolrQuery::getFacetSort([string field_override])
3980 Returns the facet sort state (for the field, if it was overridden) */
PHP_METHOD(SolrQuery,getFacetSort)3981 PHP_METHOD(SolrQuery, getFacetSort)
3982 {
3983 solr_param_t *solr_param = NULL;
3984
3985 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
3986
3987 /* Field name override, if any */
3988 solr_char_t *field_name = NULL;
3989 COMPAT_ARG_SIZE_T field_name_len = 0;
3990
3991 /* Set if the parameter was found in the HashTable and off otherwise */
3992 zend_bool param_is_set = 1;
3993
3994 memset(&field_override_buffer, 0, sizeof(solr_string_t));
3995
3996 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
3997
3998 php_error_docref(NULL, E_WARNING, "Invalid parameters");
3999
4000 RETURN_NULL();
4001 }
4002
4003 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.sort");
4004
4005 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4006
4007 param_is_set = 0;
4008 }
4009
4010 solr_string_free(&field_override_buffer);
4011
4012 if (param_is_set) {
4013
4014 solr_normal_param_value_display_sort_type(solr_param, return_value);
4015
4016 return;
4017 }
4018
4019 RETURN_NULL();
4020 }
4021 /* }}} */
4022
4023 /* {{{ proto int SolrQuery::getFacetLimit([string field_override])
4024 Returns the maximum number of items for the facet */
PHP_METHOD(SolrQuery,getFacetLimit)4025 PHP_METHOD(SolrQuery, getFacetLimit)
4026 {
4027 solr_param_t *solr_param = NULL;
4028
4029 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4030
4031 /* Field name override, if any */
4032 solr_char_t *field_name = NULL;
4033 COMPAT_ARG_SIZE_T field_name_len = 0;
4034
4035 /* Set if the parameter was found in the HashTable and off otherwise */
4036 zend_bool param_is_set = 1;
4037
4038 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4039
4040 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4041
4042 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4043
4044 RETURN_NULL();
4045 }
4046
4047 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.limit");
4048
4049 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4050
4051 param_is_set = 0;
4052 }
4053
4054 solr_string_free(&field_override_buffer);
4055
4056 if (param_is_set) {
4057
4058 solr_normal_param_value_display_integer(solr_param, return_value);
4059
4060 return;
4061 }
4062
4063 RETURN_NULL();
4064 }
4065 /* }}} */
4066
4067 /* {{{ proto int SolrQuery::getFacetOffset([string field_override])
4068 Returns the offset into the list of constraints */
PHP_METHOD(SolrQuery,getFacetOffset)4069 PHP_METHOD(SolrQuery, getFacetOffset)
4070 {
4071 solr_param_t *solr_param = NULL;
4072
4073 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4074
4075 /* Field name override, if any */
4076 solr_char_t *field_name = NULL;
4077 COMPAT_ARG_SIZE_T field_name_len = 0;
4078
4079 /* Set if the parameter was found in the HashTable and off otherwise */
4080 zend_bool param_is_set = 1;
4081
4082 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4083
4084 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4085
4086 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4087
4088 RETURN_NULL();
4089 }
4090
4091 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.offset");
4092
4093 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4094
4095 param_is_set = 0;
4096 }
4097
4098 solr_string_free(&field_override_buffer);
4099
4100 if (param_is_set) {
4101
4102 solr_normal_param_value_display_integer(solr_param, return_value);
4103
4104 return;
4105 }
4106
4107 RETURN_NULL();
4108 }
4109 /* }}} */
4110
4111 /* {{{ proto int SolrQuery::getFacetMinCount([string field_override])
4112 Returns the minimum count for the facet */
PHP_METHOD(SolrQuery,getFacetMinCount)4113 PHP_METHOD(SolrQuery, getFacetMinCount)
4114 {
4115 solr_param_t *solr_param = NULL;
4116
4117 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4118
4119 /* Field name override, if any */
4120 solr_char_t *field_name = NULL;
4121 COMPAT_ARG_SIZE_T field_name_len = 0;
4122
4123 /* Set if the parameter was found in the HashTable and off otherwise */
4124 zend_bool param_is_set = 1;
4125
4126 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4127
4128 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4129
4130 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4131
4132 RETURN_NULL();
4133 }
4134
4135 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.mincount");
4136
4137 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4138
4139 param_is_set = 0;
4140 }
4141
4142 solr_string_free(&field_override_buffer);
4143
4144 if (param_is_set) {
4145
4146 solr_normal_param_value_display_integer(solr_param, return_value);
4147
4148 return;
4149 }
4150
4151 RETURN_NULL();
4152 }
4153 /* }}} */
4154
4155 /* {{{ proto bool SolrQuery::getFacetMissing([string field_override])
4156 Returns the facet.missing parameter */
PHP_METHOD(SolrQuery,getFacetMissing)4157 PHP_METHOD(SolrQuery, getFacetMissing)
4158 {
4159 solr_param_t *solr_param = NULL;
4160
4161 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4162
4163 /* Field name override, if any */
4164 solr_char_t *field_name = NULL;
4165 COMPAT_ARG_SIZE_T field_name_len = 0;
4166
4167 /* Set if the parameter was found in the HashTable and off otherwise */
4168 zend_bool param_is_set = 1;
4169
4170 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4171
4172 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4173
4174 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4175
4176 RETURN_NULL();
4177 }
4178
4179 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.missing");
4180
4181 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4182
4183 param_is_set = 0;
4184 }
4185
4186 solr_string_free(&field_override_buffer);
4187
4188 if (param_is_set) {
4189
4190 solr_normal_param_value_display_boolean(solr_param, return_value);
4191
4192 return;
4193 }
4194
4195 RETURN_NULL();
4196 }
4197 /* }}} */
4198
4199 /* {{{ proto string SolrQuery::getFacetMethod([string field_override])
4200 Returns the facet.method parameter */
PHP_METHOD(SolrQuery,getFacetMethod)4201 PHP_METHOD(SolrQuery, getFacetMethod)
4202 {
4203 solr_param_t *solr_param = NULL;
4204
4205 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4206
4207 /* Field name override, if any */
4208 solr_char_t *field_name = NULL;
4209 COMPAT_ARG_SIZE_T field_name_len = 0;
4210
4211 /* Set if the parameter was found in the HashTable and off otherwise */
4212 zend_bool param_is_set = 1;
4213
4214 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4215
4216 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4217
4218 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4219
4220 RETURN_NULL();
4221 }
4222
4223 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.method");
4224
4225 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4226
4227 param_is_set = 0;
4228 }
4229
4230 solr_string_free(&field_override_buffer);
4231
4232 if (param_is_set) {
4233
4234 solr_normal_param_value_display_string(solr_param, return_value);
4235
4236 return;
4237 }
4238
4239 RETURN_NULL();
4240 }
4241 /* }}} */
4242
4243 /* {{{ proto array SolrQuery::getFacetDateFields()
4244 Returns all the facet.date fields */
PHP_METHOD(SolrQuery,getFacetDateFields)4245 PHP_METHOD(SolrQuery, getFacetDateFields)
4246 {
4247 solr_char_t *param_name = (solr_char_t *) "facet.date";
4248 COMPAT_ARG_SIZE_T param_name_len = sizeof("facet.date")-1;
4249 solr_param_t *solr_param = NULL;
4250
4251 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4252
4253 RETURN_NULL();
4254 }
4255
4256 array_init(return_value);
4257
4258 solr_normal_param_value_display(solr_param, return_value);
4259 }
4260 /* }}} */
4261
4262 /* {{{ proto string SolrQuery::getFacetDateStart([string field_override])
4263 Returns the facet.date.start parameter */
PHP_METHOD(SolrQuery,getFacetDateStart)4264 PHP_METHOD(SolrQuery, getFacetDateStart)
4265 {
4266 solr_param_t *solr_param = NULL;
4267
4268 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4269
4270 /* Field name override, if any */
4271 solr_char_t *field_name = NULL;
4272 COMPAT_ARG_SIZE_T field_name_len = 0;
4273
4274 /* Set if the parameter was found in the HashTable and off otherwise */
4275 zend_bool param_is_set = 1;
4276
4277 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4278
4279 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4280
4281 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4282
4283 RETURN_NULL();
4284 }
4285
4286 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.date.start");
4287
4288 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4289
4290 param_is_set = 0;
4291 }
4292
4293 solr_string_free(&field_override_buffer);
4294
4295 if (param_is_set) {
4296
4297 solr_normal_param_value_display_string(solr_param, return_value);
4298
4299 return;
4300 }
4301
4302 RETURN_NULL();
4303 }
4304 /* }}} */
4305
4306 /* {{{ proto string SolrQuery::getFacetDateEnd([string field_override])
4307 Returns the facet.date.end parameter */
PHP_METHOD(SolrQuery,getFacetDateEnd)4308 PHP_METHOD(SolrQuery, getFacetDateEnd)
4309 {
4310 solr_param_t *solr_param = NULL;
4311
4312 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4313
4314 /* Field name override, if any */
4315 solr_char_t *field_name = NULL;
4316 COMPAT_ARG_SIZE_T field_name_len = 0;
4317
4318 /* Set if the parameter was found in the HashTable and off otherwise */
4319 zend_bool param_is_set = 1;
4320
4321 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4322
4323 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4324
4325 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4326
4327 RETURN_NULL();
4328 }
4329
4330 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.date.end");
4331
4332 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4333
4334 param_is_set = 0;
4335 }
4336
4337 solr_string_free(&field_override_buffer);
4338
4339 if (param_is_set) {
4340
4341 solr_normal_param_value_display_string(solr_param, return_value);
4342
4343 return;
4344 }
4345
4346 RETURN_NULL();
4347 }
4348 /* }}} */
4349
4350 /* {{{ proto string SolrQuery::getFacetDateGap([string field_override])
4351 Returns the facet.date.gap */
PHP_METHOD(SolrQuery,getFacetDateGap)4352 PHP_METHOD(SolrQuery, getFacetDateGap)
4353 {
4354 solr_param_t *solr_param = NULL;
4355
4356 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4357
4358 /* Field name override, if any */
4359 solr_char_t *field_name = NULL;
4360 COMPAT_ARG_SIZE_T field_name_len = 0;
4361
4362 /* Set if the parameter was found in the HashTable and off otherwise */
4363 zend_bool param_is_set = 1;
4364
4365 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4366
4367 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4368
4369 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4370
4371 RETURN_NULL();
4372 }
4373
4374 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.date.gap");
4375
4376 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4377
4378 param_is_set = 0;
4379 }
4380
4381 solr_string_free(&field_override_buffer);
4382
4383 if (param_is_set) {
4384
4385 solr_normal_param_value_display_string(solr_param, return_value);
4386
4387 return;
4388 }
4389
4390 RETURN_NULL();
4391 }
4392 /* }}} */
4393
4394 /* {{{ proto bool SolrQuery::getFacetDateHardEnd([string field_override])
4395 Returns the facet.date.hardend parameter */
PHP_METHOD(SolrQuery,getFacetDateHardEnd)4396 PHP_METHOD(SolrQuery, getFacetDateHardEnd)
4397 {
4398 solr_param_t *solr_param = NULL;
4399
4400 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4401
4402 /* Field name override, if any */
4403 solr_char_t *field_name = NULL;
4404 COMPAT_ARG_SIZE_T field_name_len = 0;
4405
4406 /* Set if the parameter was found in the HashTable and off otherwise */
4407 zend_bool param_is_set = 1;
4408
4409 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4410
4411 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4412
4413 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4414
4415 RETURN_NULL();
4416 }
4417
4418 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.date.hardend");
4419
4420 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4421
4422 param_is_set = 0;
4423 }
4424
4425 solr_string_free(&field_override_buffer);
4426
4427 if (param_is_set) {
4428
4429 solr_normal_param_value_display_boolean(solr_param, return_value);
4430
4431 return;
4432 }
4433
4434 RETURN_NULL();
4435 }
4436 /* }}} */
4437
4438 /* {{{ proto string SolrQuery::getFacetDateOther([string field_override])
4439 Returns the facet.date.other parameter */
PHP_METHOD(SolrQuery,getFacetDateOther)4440 PHP_METHOD(SolrQuery, getFacetDateOther)
4441 {
4442 solr_param_t *solr_param = NULL;
4443
4444 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4445
4446 /* Field name override, if any */
4447 solr_char_t *field_name = NULL;
4448 COMPAT_ARG_SIZE_T field_name_len = 0;
4449
4450 /* Set if the parameter was found in the HashTable and off otherwise */
4451 zend_bool param_is_set = 1;
4452
4453 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4454
4455 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4456
4457 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4458
4459 RETURN_NULL();
4460 }
4461
4462 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "facet.date.other");
4463
4464 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4465
4466 param_is_set = 0;
4467 }
4468
4469 solr_string_free(&field_override_buffer);
4470
4471 if (param_is_set) {
4472
4473 array_init(return_value);
4474
4475 solr_normal_param_value_display(solr_param, return_value);
4476
4477 return;
4478 }
4479
4480 RETURN_NULL();
4481 }
4482 /* }}} */
4483
4484 /* {{{ proto bool SolrQuery::getHighlight()
4485 Returns the state of the hl parameter */
PHP_METHOD(SolrQuery,getHighlight)4486 PHP_METHOD(SolrQuery, getHighlight)
4487 {
4488 solr_char_t *param_name = (solr_char_t *) "hl";
4489 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl")-1;
4490 solr_param_t *solr_param = NULL;
4491
4492 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4493
4494 RETURN_NULL();
4495 }
4496
4497 solr_normal_param_value_display_boolean(solr_param, return_value);
4498 }
4499 /* }}} */
4500
4501 /* {{{ proto array SolrQuery::getHighlightFields()
4502 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightFields)4503 PHP_METHOD(SolrQuery, getHighlightFields)
4504 {
4505 solr_char_t *param_name = (solr_char_t *) "hl.fl";
4506 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.fl")-1;
4507 solr_param_t *solr_param = NULL;
4508
4509 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4510
4511 RETURN_NULL();
4512 }
4513
4514 array_init(return_value);
4515
4516 solr_simple_list_param_value_display(solr_param, return_value);
4517 }
4518 /* }}} */
4519
4520 /* {{{ proto int SolrQuery::getHighlightSnippets([string field_override])
4521 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightSnippets)4522 PHP_METHOD(SolrQuery, getHighlightSnippets)
4523 {
4524 solr_param_t *solr_param = NULL;
4525
4526 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4527
4528 /* Field name override, if any */
4529 solr_char_t *field_name = NULL;
4530 COMPAT_ARG_SIZE_T field_name_len = 0;
4531
4532 /* Set if the parameter was found in the HashTable and off otherwise */
4533 zend_bool param_is_set = 1;
4534
4535 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4536
4537 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4538
4539 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4540
4541 RETURN_NULL();
4542 }
4543
4544 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.snippets");
4545
4546 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4547
4548 param_is_set = 0;
4549 }
4550
4551 solr_string_free(&field_override_buffer);
4552
4553 if (param_is_set) {
4554
4555 solr_normal_param_value_display_integer(solr_param, return_value);
4556
4557 return;
4558 }
4559
4560 RETURN_NULL();
4561 }
4562 /* }}} */
4563
4564 /* {{{ proto int SolrQuery::getHighlightFragsize([string field_override])
4565 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightFragsize)4566 PHP_METHOD(SolrQuery, getHighlightFragsize)
4567 {
4568 solr_param_t *solr_param = NULL;
4569
4570 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4571
4572 /* Field name override, if any */
4573 solr_char_t *field_name = NULL;
4574 COMPAT_ARG_SIZE_T field_name_len = 0;
4575
4576 /* Set if the parameter was found in the HashTable and off otherwise */
4577 zend_bool param_is_set = 1;
4578
4579 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4580
4581 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4582
4583 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4584
4585 RETURN_NULL();
4586 }
4587
4588 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.fragsize");
4589
4590 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4591
4592 param_is_set = 0;
4593 }
4594
4595 solr_string_free(&field_override_buffer);
4596
4597 if (param_is_set) {
4598
4599 solr_normal_param_value_display_integer(solr_param, return_value);
4600
4601 return;
4602 }
4603
4604 RETURN_NULL();
4605 }
4606 /* }}} */
4607
4608 /* {{{ proto bool SolrQuery::getHighlightMergeContiguous([string field_override])
4609 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightMergeContiguous)4610 PHP_METHOD(SolrQuery, getHighlightMergeContiguous)
4611 {
4612 solr_param_t *solr_param = NULL;
4613
4614 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4615
4616 /* Field name override, if any */
4617 solr_char_t *field_name = NULL;
4618 COMPAT_ARG_SIZE_T field_name_len = 0;
4619
4620 /* Set if the parameter was found in the HashTable and off otherwise */
4621 zend_bool param_is_set = 1;
4622
4623 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4624
4625 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4626
4627 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4628
4629 RETURN_NULL();
4630 }
4631
4632 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.mergeContiguous");
4633
4634 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4635
4636 param_is_set = 0;
4637 }
4638
4639 solr_string_free(&field_override_buffer);
4640
4641 if (param_is_set) {
4642
4643 solr_normal_param_value_display_boolean(solr_param, return_value);
4644
4645 return;
4646 }
4647
4648 RETURN_NULL();
4649 }
4650 /* }}} */
4651
4652 /* {{{ proto bool SolrQuery::getHighlightRequireFieldMatch()
4653 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightRequireFieldMatch)4654 PHP_METHOD(SolrQuery, getHighlightRequireFieldMatch)
4655 {
4656 solr_char_t *param_name = (solr_char_t *) "hl.requireFieldMatch";
4657 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.requireFieldMatch")-1;
4658 solr_param_t *solr_param = NULL;
4659
4660 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4661
4662 RETURN_NULL();
4663 }
4664
4665 solr_normal_param_value_display_boolean(solr_param, return_value);
4666 }
4667 /* }}} */
4668
4669 /* {{{ proto int SolrQuery::getHighlightMaxAnalyzedChars()
4670 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightMaxAnalyzedChars)4671 PHP_METHOD(SolrQuery, getHighlightMaxAnalyzedChars)
4672 {
4673 solr_char_t *param_name = (solr_char_t *) "hl.maxAnalyzedChars";
4674 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.maxAnalyzedChars")-1;
4675 solr_param_t *solr_param = NULL;
4676
4677 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4678
4679 RETURN_NULL();
4680 }
4681
4682 solr_normal_param_value_display_integer(solr_param, return_value);
4683 }
4684 /* }}} */
4685
4686 /* {{{ proto string SolrQuery::getHighlightAlternateField([string field_override])
4687 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightAlternateField)4688 PHP_METHOD(SolrQuery, getHighlightAlternateField)
4689 {
4690 solr_param_t *solr_param = NULL;
4691
4692 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4693
4694 /* Field name override, if any */
4695 solr_char_t *field_name = NULL;
4696 COMPAT_ARG_SIZE_T field_name_len = 0;
4697
4698 /* Set if the parameter was found in the HashTable and off otherwise */
4699 zend_bool param_is_set = 1;
4700
4701 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4702
4703 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4704
4705 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4706
4707 RETURN_NULL();
4708 }
4709
4710 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.alternateField");
4711
4712 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4713
4714 param_is_set = 0;
4715 }
4716
4717 solr_string_free(&field_override_buffer);
4718
4719 if (param_is_set) {
4720
4721 solr_normal_param_value_display_string(solr_param, return_value);
4722
4723 return;
4724 }
4725
4726 RETURN_NULL();
4727 }
4728 /* }}} */
4729
4730 /* {{{ proto int SolrQuery::getHighlightMaxAlternateFieldLength([string field_override])
4731 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightMaxAlternateFieldLength)4732 PHP_METHOD(SolrQuery, getHighlightMaxAlternateFieldLength)
4733 {
4734 solr_param_t *solr_param = NULL;
4735
4736 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4737
4738 /* Field name override, if any */
4739 solr_char_t *field_name = NULL;
4740 COMPAT_ARG_SIZE_T field_name_len = 0;
4741
4742 /* Set if the parameter was found in the HashTable and off otherwise */
4743 zend_bool param_is_set = 1;
4744
4745 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4746
4747 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4748
4749 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4750
4751 RETURN_NULL();
4752 }
4753
4754 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.maxAlternateFieldLength");
4755
4756 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4757
4758 param_is_set = 0;
4759 }
4760
4761 solr_string_free(&field_override_buffer);
4762
4763 if (param_is_set) {
4764
4765 solr_normal_param_value_display_integer(solr_param, return_value);
4766
4767 return;
4768 }
4769
4770 RETURN_NULL();
4771 }
4772 /* }}} */
4773
4774 /* {{{ proto string SolrQuery::getHighlightFormatter([string field_override])
4775 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightFormatter)4776 PHP_METHOD(SolrQuery, getHighlightFormatter)
4777 {
4778 solr_param_t *solr_param = NULL;
4779
4780 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4781
4782 /* Field name override, if any */
4783 solr_char_t *field_name = NULL;
4784 COMPAT_ARG_SIZE_T field_name_len = 0;
4785
4786 /* Set if the parameter was found in the HashTable and off otherwise */
4787 zend_bool param_is_set = 1;
4788
4789 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4790
4791 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4792
4793 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4794
4795 RETURN_NULL();
4796 }
4797
4798 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.formatter");
4799
4800 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4801
4802 param_is_set = 0;
4803 }
4804
4805 solr_string_free(&field_override_buffer);
4806
4807 if (param_is_set) {
4808
4809 solr_normal_param_value_display_string(solr_param, return_value);
4810
4811 return;
4812 }
4813
4814 RETURN_NULL();
4815 }
4816 /* }}} */
4817
4818 /* {{{ proto string SolrQuery::getHighlightSimplePre([string field_override])
4819 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightSimplePre)4820 PHP_METHOD(SolrQuery, getHighlightSimplePre)
4821 {
4822 solr_param_t *solr_param = NULL;
4823
4824 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4825
4826 /* Field name override, if any */
4827 solr_char_t *field_name = NULL;
4828 COMPAT_ARG_SIZE_T field_name_len = 0;
4829
4830 /* Set if the parameter was found in the HashTable and off otherwise */
4831 zend_bool param_is_set = 1;
4832
4833 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4834
4835 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4836
4837 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4838
4839 RETURN_NULL();
4840 }
4841
4842 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.simple.pre");
4843
4844 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4845
4846 param_is_set = 0;
4847 }
4848
4849 solr_string_free(&field_override_buffer);
4850
4851 if (param_is_set) {
4852
4853 solr_normal_param_value_display_string(solr_param, return_value);
4854
4855 return;
4856 }
4857
4858 RETURN_NULL();
4859 }
4860 /* }}} */
4861
4862 /* {{{ proto string SolrQuery::getHighlightSimplePost([string field_override])
4863 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightSimplePost)4864 PHP_METHOD(SolrQuery, getHighlightSimplePost)
4865 {
4866 solr_param_t *solr_param = NULL;
4867
4868 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4869
4870 /* Field name override, if any */
4871 solr_char_t *field_name = NULL;
4872 COMPAT_ARG_SIZE_T field_name_len = 0;
4873
4874 /* Set if the parameter was found in the HashTable and off otherwise */
4875 zend_bool param_is_set = 1;
4876
4877 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4878
4879 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4880
4881 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4882
4883 RETURN_NULL();
4884 }
4885
4886 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.simple.post");
4887
4888 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4889
4890 param_is_set = 0;
4891 }
4892
4893 solr_string_free(&field_override_buffer);
4894
4895 if (param_is_set) {
4896
4897 solr_normal_param_value_display_string(solr_param, return_value);
4898
4899 return;
4900 }
4901
4902 RETURN_NULL();
4903 }
4904 /* }}} */
4905
4906 /* {{{ proto string SolrQuery::getHighlightFragmenter([string field_override])
4907 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightFragmenter)4908 PHP_METHOD(SolrQuery, getHighlightFragmenter)
4909 {
4910 solr_param_t *solr_param = NULL;
4911
4912 solr_string_t field_override_buffer; /* Field name buffer to prepare field override */
4913
4914 /* Field name override, if any */
4915 solr_char_t *field_name = NULL;
4916 COMPAT_ARG_SIZE_T field_name_len = 0;
4917
4918 /* Set if the parameter was found in the HashTable and off otherwise */
4919 zend_bool param_is_set = 1;
4920
4921 memset(&field_override_buffer, 0, sizeof(solr_string_t));
4922
4923 if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &field_name, &field_name_len) == FAILURE) {
4924
4925 php_error_docref(NULL, E_WARNING, "Invalid parameters");
4926
4927 RETURN_NULL();
4928 }
4929
4930 solr_query_field_override(&field_override_buffer, field_name, field_name_len, "hl.fragmenter");
4931
4932 if (solr_param_find(getThis(), field_override_buffer.str, field_override_buffer.len, (solr_param_t **) &solr_param) == FAILURE) {
4933
4934 param_is_set = 0;
4935 }
4936
4937 solr_string_free(&field_override_buffer);
4938
4939 if (param_is_set) {
4940
4941 solr_normal_param_value_display_string(solr_param, return_value);
4942
4943 return;
4944 }
4945
4946 RETURN_NULL();
4947 }
4948 /* }}} */
4949
4950 /* {{{ proto bool SolrQuery::getHighlightUsePhraseHighlighter()
4951 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightUsePhraseHighlighter)4952 PHP_METHOD(SolrQuery, getHighlightUsePhraseHighlighter)
4953 {
4954 solr_char_t *param_name = (solr_char_t *) "hl.usePhraseHighlighter";
4955 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.usePhraseHighlighter")-1;
4956 solr_param_t *solr_param = NULL;
4957
4958 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4959
4960 RETURN_NULL();
4961 }
4962
4963 solr_normal_param_value_display_boolean(solr_param, return_value);
4964 }
4965 /* }}} */
4966
4967 /* {{{ proto bool SolrQuery::getHighlightHighlightMultiTerm()
4968 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightHighlightMultiTerm)4969 PHP_METHOD(SolrQuery, getHighlightHighlightMultiTerm)
4970 {
4971 solr_char_t *param_name = (solr_char_t *) "hl.highlightMultiTerm";
4972 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.highlightMultiTerm")-1;
4973 solr_param_t *solr_param = NULL;
4974
4975 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4976
4977 RETURN_NULL();
4978 }
4979
4980 solr_normal_param_value_display_boolean(solr_param, return_value);
4981 }
4982 /* }}} */
4983
4984 /* {{{ proto float SolrQuery::getHighlightRegexSlop()
4985 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightRegexSlop)4986 PHP_METHOD(SolrQuery, getHighlightRegexSlop)
4987 {
4988 solr_char_t *param_name = (solr_char_t *) "hl.regex.slop";
4989 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.regex.slop")-1;
4990 solr_param_t *solr_param = NULL;
4991
4992 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
4993
4994 RETURN_NULL();
4995 }
4996
4997 solr_normal_param_value_display_double(solr_param, return_value);
4998 }
4999 /* }}} */
5000
5001 /* {{{ proto string SolrQuery::getHighlightRegexPattern()
5002 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightRegexPattern)5003 PHP_METHOD(SolrQuery, getHighlightRegexPattern)
5004 {
5005 solr_char_t *param_name = (solr_char_t *) "hl.regex.pattern";
5006 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.regex.pattern")-1;
5007 solr_param_t *solr_param = NULL;
5008
5009 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5010
5011 RETURN_NULL();
5012 }
5013
5014 solr_normal_param_value_display_string(solr_param, return_value);
5015 }
5016 /* }}} */
5017
5018 /* {{{ proto int SolrQuery::getHighlightRegexMaxAnalyzedChars()
5019 Returns the parameter */
PHP_METHOD(SolrQuery,getHighlightRegexMaxAnalyzedChars)5020 PHP_METHOD(SolrQuery, getHighlightRegexMaxAnalyzedChars)
5021 {
5022 solr_char_t *param_name = (solr_char_t *) "hl.regex.maxAnalyzedChars";
5023 COMPAT_ARG_SIZE_T param_name_len = sizeof("hl.regex.maxAnalyzedChars")-1;
5024 solr_param_t *solr_param = NULL;
5025
5026 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5027
5028 RETURN_NULL();
5029 }
5030
5031 solr_normal_param_value_display_integer(solr_param, return_value);
5032 }
5033 /* }}} */
5034
5035 /* {{{ proto bool SolrQuery::getStats()
5036 Returns the status of the stats parameter */
PHP_METHOD(SolrQuery,getStats)5037 PHP_METHOD(SolrQuery, getStats)
5038 {
5039 solr_char_t *param_name = (solr_char_t *) "stats";
5040 COMPAT_ARG_SIZE_T param_name_len = sizeof("stats")-1;
5041 solr_param_t *solr_param = NULL;
5042
5043 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5044
5045 RETURN_NULL();
5046 }
5047
5048 solr_normal_param_value_display_boolean(solr_param, return_value);
5049 }
5050 /* }}} */
5051
5052 /* {{{ proto array SolrQuery::getStatsFields()
5053 Returns the stats.field parameters */
PHP_METHOD(SolrQuery,getStatsFields)5054 PHP_METHOD(SolrQuery, getStatsFields)
5055 {
5056 solr_char_t *param_name = (solr_char_t *) "stats.field";
5057 COMPAT_ARG_SIZE_T param_name_len = sizeof("stats.field")-1;
5058 solr_param_t *solr_param = NULL;
5059
5060 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5061
5062 RETURN_NULL();
5063 }
5064
5065 array_init(return_value);
5066
5067 solr_normal_param_value_display(solr_param, return_value);
5068 }
5069 /* }}} */
5070
5071 /* {{{ proto string SolrQuery::getStatsFacets()
5072 Returns all the stats facets */
PHP_METHOD(SolrQuery,getStatsFacets)5073 PHP_METHOD(SolrQuery, getStatsFacets)
5074 {
5075 solr_char_t *param_name = (solr_char_t *) "stats.facet";
5076 COMPAT_ARG_SIZE_T param_name_len = sizeof("stats.facet")-1;
5077 solr_param_t *solr_param = NULL;
5078
5079 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5080
5081 RETURN_NULL();
5082 }
5083
5084 array_init(return_value);
5085
5086 solr_normal_param_value_display(solr_param, return_value);
5087 }
5088 /* }}} */
5089
5090 /* {{{ proto bool SolrQuery::getMlt()
5091 Returns the parameter */
PHP_METHOD(SolrQuery,getMlt)5092 PHP_METHOD(SolrQuery, getMlt)
5093 {
5094 solr_char_t *param_name = (solr_char_t *) "mlt";
5095 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt")-1;
5096 solr_param_t *solr_param = NULL;
5097
5098 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5099
5100 RETURN_NULL();
5101 }
5102
5103 solr_normal_param_value_display_boolean(solr_param, return_value);
5104 }
5105 /* }}} */
5106
5107 /* {{{ proto int SolrQuery::getMltCount()
5108 Returns the parameter */
PHP_METHOD(SolrQuery,getMltCount)5109 PHP_METHOD(SolrQuery, getMltCount)
5110 {
5111 solr_char_t *param_name = (solr_char_t *) "mlt.count";
5112 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.count")-1;
5113 solr_param_t *solr_param = NULL;
5114
5115 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5116
5117 RETURN_NULL();
5118 }
5119
5120 solr_normal_param_value_display_integer(solr_param, return_value);
5121 }
5122 /* }}} */
5123
5124 /* {{{ proto array SolrQuery::getMltFields()
5125 Returns the parameter */
PHP_METHOD(SolrQuery,getMltFields)5126 PHP_METHOD(SolrQuery, getMltFields)
5127 {
5128 solr_char_t *param_name = (solr_char_t *) "mlt.fl";
5129 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.fl")-1;
5130 solr_param_t *solr_param = NULL;
5131
5132 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5133
5134 RETURN_NULL();
5135 }
5136
5137 array_init(return_value);
5138
5139 solr_simple_list_param_value_display(solr_param, return_value);
5140 }
5141 /* }}} */
5142
5143 /* {{{ proto array SolrQuery::getMltQueryFields()
5144 Returns the parameter */
PHP_METHOD(SolrQuery,getMltQueryFields)5145 PHP_METHOD(SolrQuery, getMltQueryFields)
5146 {
5147 solr_char_t *param_name = (solr_char_t *) "mlt.qf";
5148 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.qf")-1;
5149 solr_param_t *solr_param = NULL;
5150
5151 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5152
5153 RETURN_NULL();
5154 }
5155
5156 array_init(return_value);
5157
5158 solr_arg_list_param_value_display(solr_param, return_value);
5159 }
5160 /* }}} */
5161
5162 /* {{{ proto int SolrQuery::getMltMinTermFrequency()
5163 Returns the parameter */
PHP_METHOD(SolrQuery,getMltMinTermFrequency)5164 PHP_METHOD(SolrQuery, getMltMinTermFrequency)
5165 {
5166 solr_char_t *param_name = (solr_char_t *) "mlt.mintf";
5167 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.mintf")-1;
5168 solr_param_t *solr_param = NULL;
5169
5170 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5171
5172 RETURN_NULL();
5173 }
5174
5175 solr_normal_param_value_display_integer(solr_param, return_value);
5176 }
5177 /* }}} */
5178
5179 /* {{{ proto int SolrQuery::getMltMinDocFrequency()
5180 Returns the parameter */
PHP_METHOD(SolrQuery,getMltMinDocFrequency)5181 PHP_METHOD(SolrQuery, getMltMinDocFrequency)
5182 {
5183 solr_char_t *param_name = (solr_char_t *) "mlt.mindf";
5184 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.mindf")-1;
5185 solr_param_t *solr_param = NULL;
5186
5187 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5188
5189 RETURN_NULL();
5190 }
5191
5192 solr_normal_param_value_display_integer(solr_param, return_value);
5193 }
5194 /* }}} */
5195
5196 /* {{{ proto int SolrQuery::getMltMinWordLength()
5197 Returns the parameter */
PHP_METHOD(SolrQuery,getMltMinWordLength)5198 PHP_METHOD(SolrQuery, getMltMinWordLength)
5199 {
5200 solr_char_t *param_name = (solr_char_t *) "mlt.minwl";
5201 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.minwl")-1;
5202 solr_param_t *solr_param = NULL;
5203
5204 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5205
5206 RETURN_NULL();
5207 }
5208
5209 solr_normal_param_value_display_integer(solr_param, return_value);
5210 }
5211 /* }}} */
5212
5213 /* {{{ proto int SolrQuery::getMltMaxWordLength()
5214 Returns the parameter */
PHP_METHOD(SolrQuery,getMltMaxWordLength)5215 PHP_METHOD(SolrQuery, getMltMaxWordLength)
5216 {
5217 solr_char_t *param_name = (solr_char_t *) "mlt.maxwl";
5218 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.maxwl")-1;
5219 solr_param_t *solr_param = NULL;
5220
5221 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5222
5223 RETURN_NULL();
5224 }
5225
5226 solr_normal_param_value_display_integer(solr_param, return_value);
5227 }
5228 /* }}} */
5229
5230 /* {{{ proto int SolrQuery::getMltMaxNumTokens()
5231 Returns the parameter */
PHP_METHOD(SolrQuery,getMltMaxNumTokens)5232 PHP_METHOD(SolrQuery, getMltMaxNumTokens)
5233 {
5234 solr_char_t *param_name = (solr_char_t *) "mlt.maxntp";
5235 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.maxntp")-1;
5236 solr_param_t *solr_param = NULL;
5237
5238 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5239
5240 RETURN_NULL();
5241 }
5242
5243 solr_normal_param_value_display_integer(solr_param, return_value);
5244 }
5245 /* }}} */
5246
5247 /* {{{ proto int SolrQuery::getMltMaxNumQueryTerms()
5248 Returns the parameter */
PHP_METHOD(SolrQuery,getMltMaxNumQueryTerms)5249 PHP_METHOD(SolrQuery, getMltMaxNumQueryTerms)
5250 {
5251 solr_char_t *param_name = (solr_char_t *) "mlt.maxqt";
5252 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.maxqt")-1;
5253 solr_param_t *solr_param = NULL;
5254
5255 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5256
5257 RETURN_NULL();
5258 }
5259
5260 solr_normal_param_value_display_integer(solr_param, return_value);
5261 }
5262 /* }}} */
5263
5264 /* {{{ proto bool SolrQuery::getMltBoost()
5265 Returns the parameter */
PHP_METHOD(SolrQuery,getMltBoost)5266 PHP_METHOD(SolrQuery, getMltBoost)
5267 {
5268 solr_char_t *param_name = (solr_char_t *) "mlt.boost";
5269 COMPAT_ARG_SIZE_T param_name_len = sizeof("mlt.boost")-1;
5270 solr_param_t *solr_param = NULL;
5271
5272 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5273
5274 RETURN_NULL();
5275 }
5276
5277 solr_normal_param_value_display_boolean(solr_param, return_value);
5278 }
5279 /* }}} */
5280
5281 /* {{{ proto bool SolrQuery::getTerms()
5282 Returns the parameter */
PHP_METHOD(SolrQuery,getTerms)5283 PHP_METHOD(SolrQuery, getTerms)
5284 {
5285 solr_char_t *param_name = (solr_char_t *) "terms";
5286 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms")-1;
5287 solr_param_t *solr_param = NULL;
5288
5289 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5290
5291 RETURN_NULL();
5292 }
5293
5294 solr_normal_param_value_display_boolean(solr_param, return_value);
5295 }
5296 /* }}} */
5297
5298 /* {{{ proto string SolrQuery::getTermsField()
5299 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsField)5300 PHP_METHOD(SolrQuery, getTermsField)
5301 {
5302 solr_char_t *param_name = (solr_char_t *) "terms.fl";
5303 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.fl")-1;
5304 solr_param_t *solr_param = NULL;
5305
5306 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5307
5308 RETURN_NULL();
5309 }
5310
5311 solr_normal_param_value_display_string(solr_param, return_value);
5312 }
5313 /* }}} */
5314
5315 /* {{{ proto string SolrQuery::getTermsLowerBound()
5316 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsLowerBound)5317 PHP_METHOD(SolrQuery, getTermsLowerBound)
5318 {
5319 solr_char_t *param_name = (solr_char_t *) "terms.lower";
5320 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.lower")-1;
5321 solr_param_t *solr_param = NULL;
5322
5323 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5324
5325 RETURN_NULL();
5326 }
5327
5328 solr_normal_param_value_display_string(solr_param, return_value);
5329 }
5330 /* }}} */
5331
5332 /* {{{ proto string SolrQuery::getTermsUpperBound()
5333 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsUpperBound)5334 PHP_METHOD(SolrQuery, getTermsUpperBound)
5335 {
5336 solr_char_t *param_name = (solr_char_t *) "terms.upper";
5337 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.upper")-1;
5338 solr_param_t *solr_param = NULL;
5339
5340 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5341
5342 RETURN_NULL();
5343 }
5344
5345 solr_normal_param_value_display_string(solr_param, return_value);
5346 }
5347 /* }}} */
5348
5349 /* {{{ proto bool SolrQuery::getTermsIncludeLowerBound()
5350 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsIncludeLowerBound)5351 PHP_METHOD(SolrQuery, getTermsIncludeLowerBound)
5352 {
5353 solr_char_t *param_name = (solr_char_t *) "terms.lower.incl";
5354 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.lower.incl")-1;
5355 solr_param_t *solr_param = NULL;
5356
5357 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5358
5359 RETURN_NULL();
5360 }
5361
5362 solr_normal_param_value_display_boolean(solr_param, return_value);
5363 }
5364 /* }}} */
5365
5366 /* {{{ proto bool SolrQuery::getTermsIncludeUpperBound()
5367 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsIncludeUpperBound)5368 PHP_METHOD(SolrQuery, getTermsIncludeUpperBound)
5369 {
5370 solr_char_t *param_name = (solr_char_t *) "terms.upper.incl";
5371 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.upper.incl")-1;
5372 solr_param_t *solr_param = NULL;
5373
5374 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5375
5376 RETURN_NULL();
5377 }
5378
5379 solr_normal_param_value_display_boolean(solr_param, return_value);
5380 }
5381 /* }}} */
5382
5383 /* {{{ proto int SolrQuery::getTermsMinCount()
5384 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsMinCount)5385 PHP_METHOD(SolrQuery, getTermsMinCount)
5386 {
5387 solr_char_t *param_name = (solr_char_t *) "terms.mincount";
5388 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.mincount")-1;
5389 solr_param_t *solr_param = NULL;
5390
5391 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5392
5393 RETURN_NULL();
5394 }
5395
5396 solr_normal_param_value_display_integer(solr_param, return_value);
5397 }
5398 /* }}} */
5399
5400 /* {{{ proto int SolrQuery::getTermsMaxCount()
5401 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsMaxCount)5402 PHP_METHOD(SolrQuery, getTermsMaxCount)
5403 {
5404 solr_char_t *param_name = (solr_char_t *) "terms.maxcount";
5405 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.maxcount")-1;
5406 solr_param_t *solr_param = NULL;
5407
5408 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5409
5410 RETURN_NULL();
5411 }
5412
5413 solr_normal_param_value_display_integer(solr_param, return_value);
5414 }
5415 /* }}} */
5416
5417 /* {{{ proto string SolrQuery::getTermsPrefix()
5418 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsPrefix)5419 PHP_METHOD(SolrQuery, getTermsPrefix)
5420 {
5421 solr_char_t *param_name = (solr_char_t *) "terms.prefix";
5422 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.prefix")-1;
5423 solr_param_t *solr_param = NULL;
5424
5425 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5426
5427 RETURN_NULL();
5428 }
5429
5430 solr_normal_param_value_display_string(solr_param, return_value);
5431 }
5432 /* }}} */
5433
5434 /* {{{ proto int SolrQuery::getTermsLimit()
5435 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsLimit)5436 PHP_METHOD(SolrQuery, getTermsLimit)
5437 {
5438 solr_char_t *param_name = (solr_char_t *) "terms.limit";
5439 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.limit")-1;
5440 solr_param_t *solr_param = NULL;
5441
5442 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5443
5444 RETURN_NULL();
5445 }
5446
5447 solr_normal_param_value_display_integer(solr_param, return_value);
5448 }
5449 /* }}} */
5450
5451 /* {{{ proto bool SolrQuery::getTermsReturnRaw()
5452 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsReturnRaw)5453 PHP_METHOD(SolrQuery, getTermsReturnRaw)
5454 {
5455 solr_char_t *param_name = (solr_char_t *) "terms.raw";
5456 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.raw")-1;
5457 solr_param_t *solr_param = NULL;
5458
5459 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5460
5461 RETURN_NULL();
5462 }
5463
5464 solr_normal_param_value_display_boolean(solr_param, return_value);
5465 }
5466 /* }}} */
5467
5468 /* {{{ proto int SolrQuery::getTermsSort()
5469 Returns the parameter */
PHP_METHOD(SolrQuery,getTermsSort)5470 PHP_METHOD(SolrQuery, getTermsSort)
5471 {
5472 solr_char_t *param_name = (solr_char_t *) "terms.sort";
5473 COMPAT_ARG_SIZE_T param_name_len = sizeof("terms.sort")-1;
5474 solr_param_t *solr_param = NULL;
5475
5476 if (solr_param_find(getThis(), param_name, param_name_len, (solr_param_t **) &solr_param) == FAILURE) {
5477
5478 RETURN_NULL();
5479 }
5480
5481 solr_normal_param_value_display_sort_type(solr_param, return_value);
5482 }
5483 /* }}} */
5484
5485 /* }}} End of getter methods */
5486
5487 /*
5488 * Local variables:
5489 * tab-width: 4
5490 * c-basic-offset: 4
5491 * indent-tabs-mode: t
5492 * End:
5493 * vim600: fdm=marker
5494 * vim: noet sw=4 ts=4
5495 */
5496