int main (int argc, char * argv[])
{
char * filename = argv[1];
Program_Module m = Program_ModuleNew();
Program_ParseArguments (m, argc, argv);
printf ("Compiling %s\n", String_Data (m->options.file));
if (Parse_File (m, m->options.file) != 0)
{
printf ("Lex errors: %lu\n", Vector_Size (&m->errors.lexer));
VECTOR_FOREACH (struct Error_t, error, &m->errors.lexer)
{
Error_Print (stdout, error);
}
printf ("Parse errors: %lu\n", Vector_Size (&m->errors.parser));
VECTOR_FOREACH (struct Error_t, error, &m->errors.parser)
{
Error_Print (stdout, error);
}
VECTOR_FOREACH (struct Program_Option_t, o, &m->options.debug)
{
if (String_Equal (&o->key, "parse-only"))
{
printf ("Exiting, because of '%s'.\n", o->key.data);
exit (0);
}
}
printf ("Exiting, fix the errors and try again.");
exit (0);
}
TEST_F(RangeTest, testRangeTree) {
NumericRangeTree *t = NewNumericRangeTree();
ASSERT_TRUE(t != NULL);
for (size_t i = 0; i < 50000; i++) {
NumericRangeTree_Add(t, i + 1, (double)(1 + prng() % 5000));
}
ASSERT_EQ(t->numRanges, 16);
ASSERT_EQ(t->numEntries, 50000);
struct {
double min;
double max;
} rngs[] = {{0, 100}, {10, 1000}, {2500, 3500}, {0, 5000}, {4999, 4999}, {0, 0}};
for (int r = 0; rngs[r].min || rngs[r].max; r++) {
Vector *v = NumericRangeTree_Find(t, rngs[r].min, rngs[r].max);
ASSERT_TRUE(Vector_Size(v) > 0);
// printf("Got %d ranges for %f..%f...\n", Vector_Size(v), rngs[r].min, rngs[r].max);
for (int i = 0; i < Vector_Size(v); i++) {
NumericRange *l;
Vector_Get(v, i, &l);
ASSERT_TRUE(l);
// printf("%f...%f\n", l->minVal, l->maxVal);
ASSERT_FALSE(l->minVal > rngs[r].max);
ASSERT_FALSE(l->maxVal < rngs[r].min);
}
Vector_Free(v);
}
NumericRangeTree_Free(t);
}
dfaNode *__dfn_getCache(Vector *cache, sparseVector *v) {
size_t n = Vector_Size(cache);
for (int i = 0; i < n; i++) {
dfaNode *dfn;
Vector_Get(cache, i, &dfn);
if (__sv_equals(v, dfn->v)) {
return dfn;
}
}
return NULL;
}
void Free_AST_OrderNode(AST_OrderNode *orderNode) {
if(orderNode != NULL) {
for(int i = 0; i < Vector_Size(orderNode->columns); i++) {
AST_ColumnNode *c = NULL;
Vector_Get(orderNode->columns, i , &c);
Free_AST_ColumnNode(c);
}
Vector_Free(orderNode->columns);
free(orderNode);
}
}
/*
* Before the ExecutionPlan has been constructed, we can analyze the FilterTree
* to see if a scan operation can employ an index. This function will return the iterator
* required for constructing an indexScan operation.
*/
IndexIterator* Index_IntersectFilters(RedisModuleCtx *ctx, const char *graphName, Vector *filters, const char *label) {
FT_PredicateNode *const_filter;
Index *idx;
while (Vector_Size(filters) > 0) {
Vector_Pop(filters, &const_filter);
// Look this property up to see if it has been indexed (using the label rather than the node alias)
if ((idx = Index_Get(ctx, graphName, label, const_filter->Lop.property)) != NULL) {
// Build an iterator from the first matching index
return IndexIterator_CreateFromFilter(idx, const_filter);
}
}
return NULL;
}
void Free_AST_GraphEntity(AST_GraphEntity *graphEntity) {
if(graphEntity->label != NULL) {
free(graphEntity->label);
}
if(graphEntity->alias != NULL) {
free(graphEntity->alias);
}
if(graphEntity->properties != NULL) {
for(int i = 0; i < Vector_Size(graphEntity->properties); i++) {
SIValue *val;
Vector_Get(graphEntity->properties, i, &val);
SIValue_Free(val);
free(val);
}
Vector_Free(graphEntity->properties);
}
free(graphEntity);
}
