ferret 0.3.2 → 0.9.0

data/ext/similarity.c

@@ -1,59 +1,163 @@
-#include "ferret.h"
+#include <search.h>
+#include <global.h>
 #include <math.h>
 
-/****************************************************************************
- *
- * Similarity Methods
- *
- ****************************************************************************/
+static int low_bit = 0, low_mid_bit = 0, high_mid_bit = 0, high_bit = 0;
+static void
+setup_endian()
+{
+    static int init = 0;
+    char *p;
+
+    if (init) return;
+    init = 1;
+    p = (char*)&init;
 
-/*
-static VALUE
-frt_sim_c_byte_to_float(VALUE self, VALUE rbyte)
+    if (p[0]) {
+      low_bit = 0;
+      low_mid_bit = 1;
+      high_mid_bit = 2;
+      high_bit = 3;
+    } else {
+      low_bit = 3;
+      low_mid_bit = 2;
+      high_mid_bit = 1;
+      high_bit = 0;
+    }
+}
+
+float byte_to_float(uchar b)
 {
-  int b = FIX2INT(rbyte);
+  char flt[4];
   if (b == 0)
-    return rb_float_new(0.0);
+    return 0.0;
   int mantissa = b & 0x07;           // 0x07 =  7 = 0b00000111
   int exponent = (b >> 3) & 0x1F;    // 0x1f = 31 = 0b00011111
-  int val = (mantissa << 21) | ((exponent + 48) << 24);
-  void *tmp = &val;
-  return rb_float_new(*(float *)tmp);
+
+  if (!low_mid_bit) setup_endian();
+  flt[low_bit] = flt[low_mid_bit] = 0;
+  flt[high_mid_bit] = mantissa << 5;
+  flt[high_bit] = exponent + 48;
+  return *((float *)flt);
+}
+
+uchar float_to_byte(float f)
+{
+  if (f <= 0.0)
+    return 0;
+
+  char *bits = (char *)&f;
+  int mantissa = (bits[high_mid_bit] & 0xEf) >> 5;
+  int exponent = (bits[high_bit] - 48);
+
+  if (exponent > 0x1f) {
+    exponent = 0x1f;   // 0x1f = 31 = 0b00011111
+    mantissa = 0x07;   // 0x07 =  7 = 0b00000111
+  }
+
+  if (exponent < 0) {
+    exponent = 0;
+    mantissa = 1;
+  }
+
+  return ((exponent<<3) | mantissa);
+}
+
+float simdef_length_norm(Similarity *s, char *field, int num_terms)
+{
+  return 1.0 / sqrt(num_terms);  
+}
+
+float simdef_query_norm(struct Similarity *s, float sum_of_squared_weights)
+{
+  return 1.0 / sqrt(sum_of_squared_weights);
+}
+
+float simdef_tf(struct Similarity *s, float freq)
+{
+  return sqrt(freq);
+}
+
+float simdef_sloppy_freq(struct Similarity *s, int distance)
+{
+  return 1.0 / (float)(distance + 1);
 }
-*/
 
-static VALUE
-frt_dsim_tf(VALUE self, VALUE freq)
+float simdef_idf_term(struct Similarity *s, Term *term, Searcher *searcher)
 {
-  return rb_float_new(sqrt(NUM2DBL(freq)));
+  return s->idf(s, searcher->doc_freq(searcher, term), searcher->max_doc(searcher));
 }
 
-static VALUE
-frt_dsim_idf(VALUE self, VALUE rdoc_freq, VALUE rnum_docs)
+float simdef_idf_phrase(struct Similarity *s, Term **terms, int tcnt, Searcher *searcher)
 {
-  int doc_freq;
-  int num_docs = FIX2INT(rnum_docs);
-  if (num_docs == 0) return rb_float_new(0.0);
+  float idf = 0.0;
+  int i;
+  for (i = 0; i < tcnt; i++) {
+    idf += s->idf_term(s, terms[i], searcher);
+  }
+  return idf;
+}
 
-  doc_freq = FIX2INT(rdoc_freq);
-  return rb_float_new(log((double)num_docs/(double)(doc_freq+1)) + 1.0);
+float simdef_idf(struct Similarity *s, int doc_freq, int num_docs)
+{
+  return log((float)num_docs/(float)(doc_freq+1)) + 1.0;
 }
 
-/****************************************************************************
- *
- * Init Function
- *
- ****************************************************************************/
+float simdef_coord(struct Similarity *s, int overlap, int max_overlap)
+{
+  return (float)overlap / (float)max_overlap;
+}
 
-void
-Init_similarity(void)
+float simdef_decode_norm(struct Similarity *s, uchar b)
 {
-  VALUE cDefaultSimilarity;
-  /* Similarity */
-  cSimilarity = rb_define_class_under(mSearch, "Similarity", rb_cObject);
-  cDefaultSimilarity = rb_define_class_under(mSearch, "DefaultSimilarity", cSimilarity);
+  return s->norm_table[b];
+}
+
+float simdef_encode_norm(struct Similarity *s, float f)
+{
+  return float_to_byte(f);
+}
+
+void simdef_destroy(void *p)
+{
+  // nothing to do here;
+}
+
+static Similarity default_similarity = {
+  data:NULL,
+  length_norm:&simdef_length_norm,
+  query_norm:&simdef_query_norm,
+  tf:&simdef_tf,
+  sloppy_freq:&simdef_sloppy_freq,
+  idf_term:&simdef_idf_term,
+  idf_phrase:&simdef_idf_phrase,
+  idf:&simdef_idf,
+  coord:&simdef_coord,
+  decode_norm:&simdef_decode_norm,
+  encode_norm:&simdef_encode_norm,
+  destroy:&simdef_destroy
+};
+Similarity *sim_create_default()
+{
+  int i;
+  if (!default_similarity.data) {
+    for (i = 0; i < 256; i++)
+      default_similarity.norm_table[i] = byte_to_float(i);
+
+    default_similarity.data = &default_similarity;
+  }
+  return &default_similarity;
 
-  //rb_define_singleton_method(cSimilarity, "byte_to_float", frt_sim_c_byte_to_float, 1);
-  rb_define_method(cDefaultSimilarity, "tf", frt_dsim_tf, 1);
-  rb_define_method(cDefaultSimilarity, "idf", frt_dsim_idf, 2);
+//  s->length_norm = &simdef_length_norm;
+//  s->query_norm = &simdef_query_norm;
+//  s->tf = &simdef_tf;
+//  s->sloppy_freq = &simdef_sloppy_freq;
+//  s->idf_term = &simdef_idf_term;
+//  s->idf_phrase = &simdef_idf_phrase;
+//  s->idf = &simdef_idf;
+//  s->coord = &simdef_coord;
+//  s->decode_norm = &simdef_decode_norm;
+//  s->encode_norm = &simdef_encode_norm;
+//  s->destroy = &simdef_destroy;
+//  return s;
 }

data/ext/sort.c

@@ -0,0 +1,661 @@
+#include <string.h>
+#include "search.h"
+#include "index.h"
+
+/***************************************************************************
+ *
+ * SortField
+ *
+ ***************************************************************************/
+
+unsigned int sort_field_hash(const void *p)
+{
+  SortField *self = (SortField *)p;
+  return str_hash(self->field) ^ (self->type*37);
+}
+
+int sort_field_eq(const void *p1, const void *p2)
+{
+  SortField *key1 = (SortField *)p1;
+  SortField *key2 = (SortField *)p2;
+  int equal = (strcmp(key1->field, key2->field) == 0) && key1->type == key2->type;
+  /* 
+   * TODO: The could probable be done more cleanly.
+   * If the sort field is an auto field then it was evaluated before it was
+   * entered into the cache so we need to pass the compare function back to
+   * the new sort field.
+   */
+  if (equal && (key1->type == SORT_TYPE_AUTO)) {
+    key2->compare = key1->compare;
+  }
+  return equal;
+}
+
+SortField *sort_field_clone(SortField *self)
+{
+  SortField *clone = ALLOC(SortField);
+  memcpy(clone, self, sizeof(SortField));
+  mutex_init(&clone->mutex, NULL);
+  clone->field = estrdup(self->field);
+  return clone;
+}
+
+SortField *sort_field_alloc(char *field, int type, bool reverse)
+{
+  SortField *self = ALLOC(SortField);
+  mutex_init(&self->mutex, NULL);
+  self->field = field ? estrdup(field) : NULL;
+  self->type = type;
+  self->reverse = reverse;
+  self->index = NULL;
+  self->destroy_index = &free;
+  self->compare = NULL;
+  return self;
+}
+
+SortField *sort_field_create(char *field, int type, bool reverse)
+{
+  SortField *sf = NULL;
+  switch (type) {
+    case SORT_TYPE_SCORE:
+      sf = sort_field_score_create(reverse);
+      break;
+    case SORT_TYPE_DOC:
+      sf = sort_field_doc_create(reverse);
+      break;
+    case SORT_TYPE_INTEGER:
+      sf = sort_field_int_create(field, reverse);
+      break;
+    case SORT_TYPE_FLOAT:
+      sf = sort_field_float_create(field, reverse);
+      break;
+    case SORT_TYPE_STRING:
+      sf = sort_field_string_create(field, reverse);
+      break;
+    case SORT_TYPE_AUTO:
+      sf = sort_field_auto_create(field, reverse);
+      break;
+  }
+  return sf;
+}
+
+void sort_field_destroy(void *p)
+{
+  SortField *self = (SortField *)p;
+  if (self->index) {
+    self->destroy_index(self->index);
+  }
+  free(self->field);
+  mutex_destroy(&self->mutex);
+  free(p);
+}
+
+/***************************************************************************
+ * ScoreSortField
+ ***************************************************************************/
+
+int sf_score_compare(void *index_ptr, Hit *hit2, Hit *hit1)
+{
+  float val1 = hit1->score;
+  float val2 = hit2->score;
+  if (val1 > val2) return 1;
+  else if (val1 < val2) return -1;
+  else return 0;
+}
+
+SortField *sort_field_score_create(bool reverse)
+{
+  SortField *self = sort_field_alloc(NULL, SORT_TYPE_SCORE, reverse);
+  self->compare = &sf_score_compare;
+  return self;
+}
+
+SortField SORT_FIELD_SCORE = {
+  field:NULL,
+  type:SORT_TYPE_SCORE,
+  reverse:false,
+  index:NULL,
+  compare:&sf_score_compare,
+  create_index:NULL,
+  destroy_index:NULL,
+  handle_term:NULL
+};
+
+SortField SORT_FIELD_SCORE_REV = {
+  field:NULL,
+  type:SORT_TYPE_SCORE,
+  reverse:true,
+  index:NULL,
+  compare:&sf_score_compare,
+  create_index:NULL,
+  destroy_index:NULL,
+  handle_term:NULL
+};
+
+/**************************************************************************
+ * DocSortField
+ ***************************************************************************/
+
+int sf_doc_compare(void *index_ptr, Hit *hit1, Hit *hit2)
+{
+  int val1 = hit1->doc;
+  int val2 = hit2->doc;
+  if (val1 > val2) return 1;
+  else if (val1 < val2) return -1;
+  else return 0;
+}
+
+SortField *sort_field_doc_create(bool reverse)
+{
+  SortField *self = sort_field_alloc(NULL, SORT_TYPE_DOC, reverse);
+  self->compare = &sf_doc_compare;
+  return self;
+}
+
+SortField SORT_FIELD_DOC = {
+  field:NULL,
+  type:SORT_TYPE_DOC,
+  reverse:false,
+  index:NULL,
+  compare:&sf_doc_compare,
+  create_index:NULL,
+  destroy_index:NULL,
+  handle_term:NULL
+};
+
+SortField SORT_FIELD_DOC_REV = {
+  field:NULL,
+  type:SORT_TYPE_DOC,
+  reverse:true,
+  index:NULL,
+  compare:&sf_doc_compare,
+  create_index:NULL,
+  destroy_index:NULL,
+  handle_term:NULL
+};
+
+/***************************************************************************
+ * IntegerSortField
+ ***************************************************************************/
+
+int sf_int_compare(void *index_ptr, Hit *hit1, Hit *hit2)
+{
+  int *index = (int *)index_ptr;
+  int val1 = index[hit1->doc];
+  int val2 = index[hit2->doc];
+  if (val1 > val2) return 1;
+  else if (val1 < val2) return -1;
+  else return 0;
+}
+
+void *sf_int_create_index(int size)
+{
+  return ALLOC_N(int, size);
+}
+
+void sf_int_handle_term(void *index_ptr, TermDocEnum *tde, char *text)
+{
+  int *index = (int *)index_ptr;
+  int val;
+  sscanf(text, "%d", &val);
+  while (tde->next(tde)) {
+    index[tde->doc_num(tde)] = val;
+  }
+}
+
+void sort_field_int_methods(SortField *self)
+{
+  self->compare = &sf_int_compare;
+  self->create_index = &sf_int_create_index;
+  self->handle_term = &sf_int_handle_term;
+}
+
+SortField *sort_field_int_create(char *field, bool reverse)
+{
+  SortField *self = sort_field_alloc(field, SORT_TYPE_INTEGER, reverse);
+  sort_field_int_methods(self);
+  return self;
+}
+
+/***************************************************************************
+ * FloatSortField
+ ***************************************************************************/
+
+int sf_float_compare(void *index_ptr, Hit *hit1, Hit *hit2)
+{
+  float *index = (float *)index_ptr;
+  float val1 = index[hit1->doc];
+  float val2 = index[hit2->doc];
+  if (val1 > val2) return 1;
+  else if (val1 < val2) return -1;
+  else return 0;
+}
+
+void *sf_float_create_index(int size)
+{
+  return ALLOC_N(float, size);
+}
+
+void sf_float_handle_term(void *index_ptr, TermDocEnum *tde, char *text)
+{
+  float *index = (float *)index_ptr;
+  float val;
+  sscanf(text, "%g", &val);
+  while (tde->next(tde)) {
+    index[tde->doc_num(tde)] = val;
+  }
+}
+
+void sort_field_float_methods(SortField *self)
+{
+  self->compare = &sf_float_compare;
+  self->create_index = &sf_float_create_index;
+  self->handle_term = &sf_float_handle_term;
+}
+
+SortField *sort_field_float_create(char *field, bool reverse)
+{
+  SortField *self = sort_field_alloc(field, SORT_TYPE_FLOAT, reverse);
+  sort_field_float_methods(self);
+  return self;
+}
+
+/***************************************************************************
+ * StringSortField
+ ***************************************************************************/
+
+#define VALUES_ARRAY_START_SIZE 8
+typedef struct StringIndex {
+  int size;
+  int *index;
+  char **values;
+  int v_cnt;
+  int v_size;
+} StringIndex;
+
+int sf_string_compare(void *index_ptr, Hit *hit1, Hit *hit2)
+{
+  StringIndex *index = (StringIndex *)index_ptr;
+  int val1 = index->index[hit1->doc];
+  int val2 = index->index[hit2->doc];
+  if (val1 > val2) return 1;
+  else if (val1 < val2) return -1;
+  else return 0;
+}
+
+void *sf_string_create_index(int size)
+{
+  StringIndex *self = ALLOC(StringIndex);
+  ZEROSET(self, StringIndex, 1);
+  self->size = size;
+  self->index = ALLOC_N(int, size);
+  ZEROSET(self->index, int, size);
+  self->v_size = VALUES_ARRAY_START_SIZE;
+  self->values = ALLOC_N(char *, VALUES_ARRAY_START_SIZE);
+  return self;
+}
+
+void sf_string_destroy_index(void *p)
+{
+  StringIndex *self = (StringIndex *)p;
+  int i;
+  free(self->index);
+  for (i = 0; i < self->v_cnt; i++) {
+    free(self->values[i]);
+  }
+  free(self->values);
+  free(self);
+}
+
+void sf_string_handle_term(void *index_ptr, TermDocEnum *tde, char *text)
+{
+  StringIndex *index = (StringIndex *)index_ptr;
+  if (index->v_cnt >= index->v_size) {
+    index->v_size *= 2;
+    index->values = REALLOC_N(index->values, char *, index->v_size);
+  }
+  index->values[index->v_cnt] = estrdup(text);
+  while (tde->next(tde)) {
+    index->index[tde->doc_num(tde)] = index->v_cnt;
+  }
+  index->v_cnt++;
+}
+
+void sort_field_string_methods(SortField *self)
+{
+  self->compare = &sf_string_compare;
+  self->create_index = &sf_string_create_index;
+  self->destroy_index = &sf_string_destroy_index;
+  self->handle_term = &sf_string_handle_term;
+}
+
+SortField *sort_field_string_create(char *field, bool reverse)
+{
+  SortField *self = sort_field_alloc(field, SORT_TYPE_STRING, reverse);
+  sort_field_string_methods(self);
+  return self;
+}
+
+/***************************************************************************
+ * AutoSortField
+ ***************************************************************************/
+
+void sort_field_auto_evaluate(SortField *sf, char *text)
+{
+  int int_val;
+  float float_val;
+  int text_len = 0, scan_len = 0;
+
+  text_len = strlen(text);
+  sscanf(text, "%d%n", &int_val, &scan_len);
+  if (scan_len == text_len) {
+    sort_field_int_methods(sf);
+  } else {
+    sscanf(text, "%f%n", &float_val, &scan_len);
+    if (scan_len == text_len) {
+      sort_field_float_methods(sf);
+    } else {
+      sort_field_string_methods(sf);
+    }
+  }
+}
+
+
+SortField *sort_field_auto_create(char *field, bool reverse)
+{
+  return sort_field_alloc(field, SORT_TYPE_AUTO, reverse);
+}
+
+/***************************************************************************
+ *
+ * FieldCache
+ *
+ ***************************************************************************/
+
+void *field_cache_get_index(IndexReader *ir, SortField *sf)
+{
+  void *index = NULL;
+  int length = 0;
+  Term term;
+  TermBuffer *tb;
+  TermEnum *te;
+  TermDocEnum *tde;
+  char *field = sf->field;
+  SortField *sf_clone;
+
+  mutex_lock(&sf->mutex);
+  if (!ir->sort_cache) {
+    ir->sort_cache = h_new(&sort_field_hash, &sort_field_eq,
+        &sort_field_destroy, NULL);
+  }
+  index = h_get(ir->sort_cache, sf);
+
+  if (index == NULL) {
+    length = ir->max_doc(ir);
+    if (length > 0) {
+      tde = ir->term_docs(ir);
+      term.field = field;
+      term.text = "";
+      te = ir->terms_from(ir, &term);
+      if (te->tb_curr == NULL) {
+        eprintf(ARG_ERROR, "no terms in field '%s' to sort by", field);
+      }
+
+      if (sf->type == SORT_TYPE_AUTO) {
+        sort_field_auto_evaluate(sf, te->tb_curr->text);
+      }
+
+      index = sf->create_index(length);
+
+      do { 
+        tb = te->tb_curr;
+        if (strcmp(tb->field, field) != 0) break;
+        term.text = tb->text;
+        tde->seek(tde, &term);
+        sf->handle_term(index, tde, tb->text);
+      } while (te->next(te));
+      tde->close(tde);
+      te->close(te);
+    }
+    sf_clone = sort_field_clone(sf);
+    sf_clone->index = index;
+    h_set(ir->sort_cache, sf_clone, index);
+  }
+  mutex_unlock(&sf->mutex);
+  return index;
+}
+
+/***************************************************************************
+ *
+ * FieldSortedHitQueue
+ *
+ ***************************************************************************/
+
+/***************************************************************************
+ * Comparator
+ ***************************************************************************/
+
+typedef struct Comparator {
+  void *index;
+  bool  reverse : 1;
+  int   (*compare)(void *index_ptr, Hit *hit1, Hit *hit2);
+} Comparator;
+
+Comparator *comparator_create(void *index, bool reverse,
+    int (*compare)(void *index_ptr, Hit *hit1, Hit *hit2))
+{
+  Comparator *self = ALLOC(Comparator);
+  self->index = index;
+  self->reverse = reverse;
+  self->compare = compare;
+  return self;
+}
+
+/***************************************************************************
+ * Sorter
+ ***************************************************************************/
+
+typedef struct Sorter {
+  Comparator **comparators;
+  int c_cnt;
+} Sorter;
+
+Comparator *sorter_get_comparator(SortField *sf, IndexReader *ir)
+{
+  void *index = NULL;
+
+  if (sf->type > SORT_TYPE_DOC) {
+    index = field_cache_get_index(ir, sf);
+  }
+  return comparator_create(index, sf->reverse, sf->compare);
+}
+
+void sorter_destroy(void *p)
+{
+  int i;
+  Sorter *self = (Sorter *)p;
+
+  for (i = 0; i < self->c_cnt; i++) {
+    free(self->comparators[i]);
+  }
+  free(self->comparators);
+  free(self);
+}
+
+Sorter *sorter_create(int size)
+{
+  Sorter *self = ALLOC(Sorter);
+  self->c_cnt = size;
+  self->comparators = ALLOC_N(Comparator *, size);
+  ZEROSET(self->comparators, Comparator *, size);
+  return self;
+}
+
+/***************************************************************************
+ * FieldSortedHitQueue
+ ***************************************************************************/
+
+bool fshq_less_than(void *hit1, void *hit2)
+{
+  printf("Whoops, shouldn't call this.\n");
+  int cmp = 0;
+  if (cmp != 0) {
+    return cmp;
+  } else {
+    return ((Hit *)hit1)->score < ((Hit *)hit2)->score;
+  }
+}
+
+inline bool fshq_lt(Hit *sorter_ptr, Hit *hit1, Hit *hit2)
+{
+  Sorter *sorter = (Sorter *)sorter_ptr;
+  Comparator *comp;
+  int diff = 0, i;
+  for (i = 0; i < sorter->c_cnt && diff == 0; i++) {
+    comp = sorter->comparators[i];
+    if (comp->reverse) {
+      diff = comp->compare(comp->index, hit2, hit1);
+    } else {
+      diff = comp->compare(comp->index, hit1, hit2);
+    }
+  }
+
+  if (diff != 0) {
+    return diff > 0;
+  } else {
+    return hit1->doc > hit2->doc;
+  }
+}
+
+void fshq_pq_down(PriorityQueue *pq)
+{
+  register int i = 1;
+  register int j = 2; //i << 1;
+  register int k = 3; //j + 1;
+  Hit **heap = (Hit **)pq->heap;
+  Hit *node = heap[i]; // save top node
+
+  if ((k <= pq->count) && fshq_lt(heap[0], heap[k], heap[j]))
+    j = k;
+
+  while ((j <= pq->count) && fshq_lt(heap[0], heap[j], node)) {
+    heap[i] = heap[j];      // shift up child
+    i = j;
+    j = i << 1;
+    k = j + 1;
+    if ((k <= pq->count) && fshq_lt(heap[0], heap[k], heap[j]))
+      j = k;
+  }
+  heap[i] = node;
+}
+
+Hit *fshq_pq_pop(PriorityQueue *pq)
+{
+  if (pq->count > 0) {
+    Hit *result = (Hit *)pq->heap[1];  // save first value
+    pq->heap[1] = pq->heap[pq->count]; // move last to first
+    pq->heap[pq->count] = NULL;
+    pq->count--;
+    fshq_pq_down(pq);                   // adjust heap
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+inline void fshq_pq_up(PriorityQueue *pq)
+{
+	int i,j;
+	i = pq->count;
+	j = i >> 1;
+  Hit **heap = (Hit **)pq->heap;
+  Hit *node = heap[i];
+
+	while ((j > 0) && fshq_lt(heap[0], node, heap[j])) {
+		heap[i] = heap[j];
+		i = j;
+		j = j >> 1;
+	}
+  heap[i] = node;
+}
+
+void fshq_pq_push(PriorityQueue *pq, void *elem)
+{
+  pq->count++;
+  pq->heap[pq->count] = elem;
+  fshq_pq_up(pq);
+}
+
+void fshq_pq_destroy(void *p)
+{
+  PriorityQueue *self = (PriorityQueue *)p; 
+  sorter_destroy(self->heap[0]);
+  pq_destroy(self);
+}
+
+PriorityQueue *fshq_pq_create(int size, Sort *sort, IndexReader *ir)
+{
+  PriorityQueue *self = pq_create(size, &fshq_less_than);
+  int i;
+  Sorter *sorter = sorter_create(sort->sf_cnt);
+  SortField *sf;
+
+  for (i = 0; i < sort->sf_cnt; i++) {
+    sf = sort->sort_fields[i];
+    sorter->comparators[i] = sorter_get_comparator(sf, ir);
+  }
+  self->heap[0] = sorter;
+  
+  return self;
+}
+
+/***************************************************************************
+ *
+ * Sort
+ *
+ ***************************************************************************/
+
+Sort *sort_create()
+{
+  Sort *self = ALLOC(Sort);
+  self->sf_cnt = 0;
+  self->sf_capa = ARRAY_INIT_SIZE;
+  self->sort_fields = ALLOC_N(SortField *, ARRAY_INIT_SIZE);
+  self->destroy_all = true;
+
+  return self;
+}
+
+void sort_clear(Sort *self)
+{
+  int i;
+  for (i = 0; i < self->sf_cnt; i++) {
+    sort_field_destroy(self->sort_fields[i]);
+  }
+  self->sf_cnt = 0;
+}
+
+void sort_destroy(void *p)
+{
+  int i;
+  Sort *self = (Sort *)p;
+  if (self->destroy_all) {
+    for (i = 0; i < self->sf_cnt; i++) {
+      sort_field_destroy(self->sort_fields[i]);
+    }
+  }
+  free(self->sort_fields);
+  free(self);
+}
+
+void sort_add_sort_field(Sort *self, SortField *sf)
+{
+  if (self->sf_cnt == self->sf_capa) {
+    self->sf_capa *= 2;
+    REALLOC_N(self->sort_fields, SortField *, self->sf_capa);
+  }
+
+  self->sort_fields[self->sf_cnt] = sf;
+  self->sf_cnt++;
+}
+