Beispiel #1
0
static void tst2(void)
{
    WRBUF w = wrbuf_alloc();
    cql_transform_t ct = 0;
    const char *srcdir = getenv("srcdir");
    if (srcdir)
    {
        wrbuf_puts(w, srcdir);
        wrbuf_puts(w, "/");
    }
    wrbuf_puts(w, "../etc/pqf.properties");
    
    ct = cql_transform_open_fname(wrbuf_cstr(w));
    YAZ_CHECK(compare(ct, "@attr 1=4 abc", "dc.title=abc"));
    YAZ_CHECK(compare(ct, "@attr 1=4 @attr 4=108 abc", "dc.title=/exact abc"));
    YAZ_CHECK(compare(ct, "@attr 1=4 @attr 3=1 @attr 6=1 abc", "dc.title=abc"));
    YAZ_CHECK(compare(ct, "@attr 1=4 @attr 4=1 @attr 6=1 abc",
                      "dc.title=abc"));
    YAZ_CHECK(compare(ct, "@attr 1=1016 abc", "abc"));
    YAZ_CHECK(compare(ct, "@attr 2=1 @attr 1=30 1980", "dc.date<1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=3 1980", "dc.date=1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=5 1980", "dc.date>1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=2 1980", "dc.date<=1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=4 1980", "dc.date>=1980"));

    YAZ_CHECK(compare(ct, "@attr 2=103 @attr 1=_ALLRECORDS 1", "cql.allRecords=1"));
    YAZ_CHECK(compare(ct, "@attr 1=500 abc", 0));
    cql_transform_close(ct);
    wrbuf_destroy(w);
}
Beispiel #2
0
static void tst2(void)
{
    WRBUF w = wrbuf_alloc();
    cql_transform_t ct = 0;
    const char *srcdir = getenv("srcdir");
    if (srcdir)
    {
        wrbuf_puts(w, srcdir);
        wrbuf_puts(w, "/");
    }
    wrbuf_puts(w, "../etc/pqf.properties");

    ct = cql_transform_open_fname(wrbuf_cstr(w));
    YAZ_CHECK(compare(ct, "@attr 1=4 abc", "dc.title=abc"));
    YAZ_CHECK(compare(ct, "@attr 1=4 @attr 4=108 abc", "dc.title=/exact abc"));
    YAZ_CHECK(compare(ct, "@attr 1=4 @attr 3=1 @attr 6=1 abc", "dc.title=abc"));
    YAZ_CHECK(compare(ct, "@attr 1=4 @attr 4=1 @attr 6=1 abc", "dc.title=abc"));
    YAZ_CHECK(compare(ct, "@attr 1=1016 abc", "abc"));
    /* Date tests */
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=1 1980", "dc.date<1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=2 1980", "dc.date<=1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=3 1980", "dc.date=1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=4 1980", "dc.date>=1980"));
    YAZ_CHECK(compare(ct, "@attr 1=30 @attr 2=5 1980", "dc.date>1980"));
    YAZ_CHECK(compare(ct, "@and @attr 1=30 @attr 2=4 234 @attr 1=30 @attr 2=2 1990", "dc.date>=234 and dc.date<=1990"));

    /* Truncation */
    YAZ_CHECK(compare(ct, "@attr 5=1 water", "water*"));
    YAZ_CHECK(compare(ct, "@attr 5=2 water", "*water"));
    YAZ_CHECK(compare(ct, "@attr 5=3 water", "*water*"));
    YAZ_CHECK(compare(ct, "@attr 5=100 water", "water"));
    YAZ_CHECK(compare(ct, "@attr 5=102 water", "water"));
    YAZ_CHECK(compare(ct, "@attr 5=104 water", "water"));

    YAZ_CHECK(compare(ct, "@attr 5=102 wat.*er", "wat*er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat?er", "wat*er"));

    YAZ_CHECK(compare(ct, "@attr 5=102 wat.er", "wat?er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat#er", "wat?er"));
    YAZ_CHECK(compare(ct, "@attr 5=102 wat?er", "wat\\?er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat*er", "wat\\*er"));
    YAZ_CHECK(compare(ct, "@attr 5=102 wat#er", "wat#er"));

    /* \. is 'eaten' by PQF parser */
    YAZ_CHECK(compare(ct, "@attr 5=102 wat\\.er", "wat?er"));

    /* Escape sequences */
    /* note: escape sequences that survive after PQF parse below */
    YAZ_CHECK(compare(ct, "@attr 5=102 wat\\\\?er", "wat\\?er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat\\\\?er", "wat\\?er"));

    YAZ_CHECK(compare(ct, "@attr 5=102 wat\\\\*er", "wat\\*er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat\\\\*er", "wat\\*er"));

    YAZ_CHECK(compare(ct, "wat\\\\#er", "wat#er"));
    YAZ_CHECK(compare(ct, "@attr 5=100 wat\\\\#er", "wat#er"));
    YAZ_CHECK(compare(ct, "@attr 5=102 wat\\\\#er", "wat#er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat\\\\#er", "wat#er"));
    YAZ_CHECK(compare(ct, "@attr 5=102 wat\\\\.er", "wat.er"));
    YAZ_CHECK(compare(ct, "@attr 5=104 wat\\\\.er", "wat.er"));

    /* Quoting */
    YAZ_CHECK(compare(ct, "@attr 5=100 \"\"", "\"\""));
    YAZ_CHECK(compare(ct, "@attr 5=1 \"\"", "\"*\""));
    YAZ_CHECK(compare(ct, "@attr 5=2 \"\"", "\"*\""));
    YAZ_CHECK(compare(ct, "@attr 5=3 \"\"", "\"**\""));
    YAZ_CHECK(compare(ct, "@attr 5=102 \"\"", "\"\""));
    YAZ_CHECK(compare(ct, "@attr 5=104 \"\"", "\"\""));

    YAZ_CHECK(compare(ct, "@attr 5=1 \"water basket\"", "\"water basket*\""));
    YAZ_CHECK(compare(ct, "@attr 5=2 \"water basket\"", "\"*water basket\""));
    YAZ_CHECK(compare(ct, "@attr 5=3 \"water basket\"", "\"*water basket*\""));

    /* Other */
    YAZ_CHECK(compare(ct, "@attr 2=103 @attr 1=_ALLRECORDS 1", "cql.allRecords=1"));
    YAZ_CHECK(compare2(ct, "@attr 1=500 abc", 0, 114));
    YAZ_CHECK(compare2(ct, "@attr 5=99 x", "99", 120));
    cql_transform_close(ct);
    wrbuf_destroy(w);
}
Beispiel #3
0
int main(int argc, char **argv)
{
    cql_transform_t ct;
    int i, iterations = 1;
    char *query = 0;
    char *fname = 0;
    int reverse = 0;

    int ret;
    char *arg;

    while ((ret = options("n:r", argv, argc, &arg)) != -2)
    {
        switch (ret)
        {
        case 0:
            if (!fname)
                fname = arg;
            else
                query = arg;
            break;
        case 'r':
            reverse = 1;
            break;
        case 'n':
            iterations = atoi(arg);
            break;
        default:
            usage();
        }
    }
    if (!fname)
        usage();
    if (!strcmp(fname, "-"))
        ct = cql_transform_create();
    else
        ct = cql_transform_open_fname(fname);
    if (!ct)
    {
        fprintf(stderr, "failed to read properties %s\n", fname);
        exit(1);
    }

    if (reverse)
    {
        if (!query)
            usage();
        else
        {
            ODR odr = odr_createmem(ODR_ENCODE);
            YAZ_PQF_Parser pp = yaz_pqf_create();
            Z_RPNQuery *rpn = yaz_pqf_parse(pp, odr, query);
            if (!rpn)
            {
                fprintf(stderr, "PQF syntax error\n");
            }
            else 
            {
                int ret = cql_transform_rpn2cql_stream(ct, cql_fputs,
                                                       stdout, rpn);
                
                if (ret)
                {
                    const char *addinfo;
                    int r = cql_transform_error(ct, &addinfo);
                    printf("Transform error %d %s\n", r, addinfo ? addinfo : "");
                }
                else
                    printf("\n");
            }
            yaz_pqf_destroy(pp);
            odr_destroy(odr);
        }
    }
    else
    {
        CQL_parser cp = cql_parser_create();
        int r = 0;
        
        if (query)
        {
            for (i = 0; i<iterations; i++)
                r = cql_parser_string(cp, query);
        }
        else
            r = cql_parser_stdio(cp, stdin);
        
        if (r)
            fprintf(stderr, "Syntax error\n");
        else
        {
            r = cql_transform_FILE(ct, cql_parser_result(cp), stdout);
            printf("\n");
            if (r)
            {
                const char *addinfo;
                r = cql_transform_error(ct, &addinfo);
                printf("Transform error %d %s\n", r, addinfo ? addinfo : "");
            }
            else
            {
                FILE *null = fopen("/dev/null", "w");
                for (i = 1; i<iterations; i++)
                    cql_transform_FILE(ct, cql_parser_result(cp), null);
                fclose(null);
            }
        }
        cql_parser_destroy(cp);
    }
    cql_transform_close(ct);
    return 0;
}
Beispiel #4
0
static void xml_config_read(void)
{
    struct gfs_server **gfsp = &gfs_server_list;
    struct gfs_listen **gfslp = &gfs_listen_list;
    xmlNodePtr ptr = xml_config_get_root();

    if (!ptr)
        return;
    for (ptr = ptr->children; ptr; ptr = ptr->next)
    {
        struct _xmlAttr *attr;
        if (ptr->type != XML_ELEMENT_NODE)
            continue;
        attr = ptr->properties;
        if (!strcmp((const char *) ptr->name, "listen"))
        {
            /*
              <listen id="listenerid">tcp:@:9999</listen>
            */
            const char *id = 0;
            const char *address =
                nmem_dup_xml_content(gfs_nmem, ptr->children);
            for ( ; attr; attr = attr->next)
                if (!xmlStrcmp(attr->name, BAD_CAST "id")
                    && attr->children && attr->children->type == XML_TEXT_NODE)
                    id = nmem_dup_xml_content(gfs_nmem, attr->children);
            if (address)
            {
                *gfslp = gfs_listen_new(id, address);
                gfslp = &(*gfslp)->next;
                *gfslp = 0; /* make listener list consistent for search */
            }
        }
        else if (!strcmp((const char *) ptr->name, "server"))
        {
            xmlNodePtr ptr_server = ptr;
            xmlNodePtr ptr;
            const char *listenref = 0;
            const char *id = 0;
            struct gfs_server *gfs;

            for ( ; attr; attr = attr->next)
                if (!xmlStrcmp(attr->name, BAD_CAST "listenref") 
                    && attr->children && attr->children->type == XML_TEXT_NODE)
                    listenref = nmem_dup_xml_content(gfs_nmem, attr->children);
                else if (!xmlStrcmp(attr->name, BAD_CAST "id")
                         && attr->children
                         && attr->children->type == XML_TEXT_NODE)
                    id = nmem_dup_xml_content(gfs_nmem, attr->children);
                else
                    yaz_log(YLOG_WARN, "Unknown attribute '%s' for server",
                            attr->name);
            gfs = *gfsp = gfs_server_new();
            gfs->server_node_ptr = ptr_server;
            if (listenref)
            {
                int id_no;
                struct gfs_listen *gl = gfs_listen_list;
                for (id_no = 1; gl; gl = gl->next, id_no++)
                    if (gl->id && !strcmp(gl->id, listenref))
                    {
                        gfs->listen_ref = id_no;
                        break;
                    }
                if (!gl)
                    yaz_log(YLOG_WARN, "Non-existent listenref '%s' in server "
                            "config element", listenref);
            }
            for (ptr = ptr_server->children; ptr; ptr = ptr->next)
            {
                if (ptr->type != XML_ELEMENT_NODE)
                    continue;
                if (!strcmp((const char *) ptr->name, "host"))
                {
                    gfs->host = nmem_dup_xml_content(gfs_nmem,
                                                     ptr->children);
                }
                else if (!strcmp((const char *) ptr->name, "config"))
                {
                    strcpy(gfs->cb.configname,
                           nmem_dup_xml_content(gfs_nmem, ptr->children));
                }
                else if (!strcmp((const char *) ptr->name, "cql2rpn"))
                {
                    gfs->cql_transform = cql_transform_open_fname(
                        nmem_dup_xml_content(gfs_nmem, ptr->children)
                        );
                }
                else if (!strcmp((const char *) ptr->name, "ccl2rpn"))
                {
                    char *name;
                    FILE *f;

                    name = nmem_dup_xml_content(gfs_nmem, ptr->children);
                    if ((f = fopen(name, "r")) == 0) {
                        yaz_log(YLOG_FATAL, "can't open CCL file '%s'", name);
                        exit(1);
                    }
                    gfs->ccl_transform = ccl_qual_mk();
                    ccl_qual_file (gfs->ccl_transform, f);
                    fclose(f);
                }
                else if (!strcmp((const char *) ptr->name, "directory"))
                {
                    gfs->directory = 
                        nmem_dup_xml_content(gfs_nmem, ptr->children);
                }
                else if (!strcmp((const char *) ptr->name, "docpath"))
                {
                    gfs->docpath = 
                        nmem_dup_xml_content(gfs_nmem, ptr->children);
                }
                else if (!strcmp((const char *) ptr->name, "maximumrecordsize"))
                {
                    gfs->cb.maxrecordsize = atoi(
                        nmem_dup_xml_content(gfs_nmem, ptr->children));
                }
                else if (!strcmp((const char *) ptr->name, "stylesheet"))
                {
                    char *s = nmem_dup_xml_content(gfs_nmem, ptr->children);
                    gfs->stylesheet = (char *)
                        nmem_malloc(gfs_nmem, strlen(s) + 2);
                    sprintf(gfs->stylesheet, "/%s", s);
                }
                else if (!strcmp((const char *) ptr->name, "explain"))
                {
                    ; /* being processed separately */
                }
                else if (!strcmp((const char *) ptr->name, "retrievalinfo"))
                {
                    if (yaz_retrieval_configure(gfs->retrieval, ptr))
                    {       
                        yaz_log(YLOG_FATAL, "%s in config %s",
                                yaz_retrieval_get_error(gfs->retrieval),
                                control_block.xml_config);
                        exit(1);
                    }
                }
                else
                {
                    yaz_log(YLOG_FATAL, "Unknown element '%s' in config %s",
                            ptr->name, control_block.xml_config);
                    exit(1);
                }
            }
            gfsp = &(*gfsp)->next;
        }
    }
    *gfsp = 0;
}