Up to [Platon] / libplaton / utils / phone-list

Added phone-list (tel-zozn) into CVS

/*
 * db-replication.c
 *
 * Developed by Ondrej Jombik <nepto@platon.sk>
 * Copyright (c) 2004 Platon SDG, http://platon.sk/
 * Licensed under terms of GNU General Public License.
 * All rights reserved.
 *
 * Changelog:
 * 2004-05-09 - created
 *
 */

/* $Platon$ */

#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <platon/str/strplus.h>
#include <platon/compress/rle.h>
#include <platon/compress/lz-rle.h>
#include <mysql/mysql.h>
#include <db.h>

#include "shared.h"

int sys_key_store(DB *dbp, char *sys_key, char *value, int size);

struct
{
    char *name;
    char *index;
    char *query;
} tel_zozn_queries[] =
{
    /* name, primary key, query */
    /* Example: {"TYP", "CISLO", "SELECT * FROM tabulka"} */
    #include "queries.txt"
    {NULL, NULL, NULL}
};

int main(int argc, char **argv) /* {{{ */
{
    unsigned char type;
    register int i, index_idx, buflen;
    unsigned int num_fields;
    char buf[BUFSIZE], buf2[BUFSIZE], sys_key[MAX_SYS_KEY_SIZE];

    MYSQL mysql;
    MYSQL_RES *mysql_res;
    MYSQL_FIELD *mysql_field;
    MYSQL_ROW mysql_row;
    register unsigned long *mysql_len;

    DB *dbp;
    DBT key, data;
    int db_ret;

    /*
     * MySQL initialization
     */

    if (mysql_init(&mysql) == NULL) {
        fprintf(stderr, "%s: cannot create MySQL handle\n", argv[0]);
        return 1;
    }

    if (mysql_real_connect(&mysql,
                DB_HOST, DB_USER, DB_PASS, DB_NAME, 0, NULL, 0) == NULL) {
        fprintf(stderr, "%s: cannot connect to database:\n  %s\n",
                argv[0], mysql_error(&mysql));
        return 1;
    }

    /*
     * Berkeley DB initialization
     */

    if ((db_ret = db_create(&dbp, NULL, 0)) != 0) {
        fprintf(stderr, "%s: db_create: %s\n", argv[0], db_strerror(db_ret));
        return 1;
    }

    if ((db_ret = dbp->set_flags(dbp, DB_DUP)) != 0
            || (db_ret = dbp->open(dbp, NULL, DB_FILE, NULL,
                    DB_BTREE, DB_CREATE|DB_TRUNCATE, 0664)) != 0) {
        dbp->err(dbp, db_ret, "%s: %s", argv[0], DB_FILE);
        return 1;
    }

    memset(&key,  0, sizeof(key));
    memset(&data, 0, sizeof(data));

    for (type = 0; tel_zozn_queries[type].query != NULL; type++) {

        printf("[%02d] %s\n     Query: %s\n     Key: %s\n", type + 1,
                tel_zozn_queries[type].name,
                tel_zozn_queries[type].query,
                tel_zozn_queries[type].index);

        if (mysql_query(&mysql, tel_zozn_queries[type].query)) {
            fprintf(stderr, "%s: error executing query:\n  %s\n",
                    argv[0], mysql_error(&mysql));
            return 1;
        }

        if ((mysql_res = mysql_store_result(&mysql)) == 0) {
            fprintf(stderr, "%s: error storing result:\n  %s\n",
                    argv[0], mysql_error(&mysql));
            return 1;
        }
        num_fields = mysql_num_fields(mysql_res);
        printf("     Column count: %u\n     Columns: ", num_fields);
        mysql_field = mysql_fetch_fields(mysql_res);
        for (index_idx = -1, buflen = 0, i = 0; i < num_fields; i++) {
            if (i > 0)
                fputs("|", stdout);
            fputs(mysql_field[i].name, stdout);
            if (! strcasecmp(tel_zozn_queries[type].index, mysql_field[i].name)) {
                index_idx = i;
                fputs("[*]", stdout);
            }
            memcpy((void *) (buf + buflen), mysql_field[i].name, strlen(mysql_field[i].name));
            buflen += strlen(mysql_field[i].name);
            buf[buflen] = '\0';
            buflen++;
        }
        puts("");
        if (index_idx < 0) {
            fprintf(stderr, "%s: cannot find key index\n", argv[0]);
            return 1;
        }
        printf("     Key index: %u\n", index_idx);

        /*
         * Table name storage
         */

        snprintf(sys_key, MAX_SYS_KEY_SIZE, "name%c", type);
        if (sys_key_store(dbp, sys_key, tel_zozn_queries[type].name, -1) < 0)
            return 1;

        /*
         * Index name storage
         */

        snprintf(sys_key, MAX_SYS_KEY_SIZE, "key-%c", type);
        if (sys_key_store(dbp, sys_key, tel_zozn_queries[type].index, -1) < 0)
            return 1;

        /*
         * Query text storage
         */

        snprintf(sys_key, MAX_SYS_KEY_SIZE, "qry-%c", type);
        if (sys_key_store(dbp, sys_key, tel_zozn_queries[type].query, -1) < 0)
            return 1;

        /*
         * Table structure (column names) storage
         */

        snprintf(sys_key, MAX_SYS_KEY_SIZE, "cols%c", type);
        if (sys_key_store(dbp, sys_key, buf, buflen) < 0)
            return 1;

        /*
         * Data storage
         */

        while ((mysql_row = mysql_fetch_row(mysql_res))) {
            mysql_len = mysql_fetch_lengths(mysql_res);
            buf[0] = type;
            for (buflen = 1, i = 0; i < num_fields; i++) {
                if (buflen + mysql_len[i] + 1 > BUFSIZE) {
                    fprintf(stderr, "%s: WARNING: buffer overflow, skipping\n", argv[0]);
                    continue;
                }
                nul_to_spaces(mysql_row[i], mysql_len[i]);
                memcpy((void *) (buf + buflen), mysql_row[i], mysql_len[i]);
                buflen += mysql_len[i];
                buf[buflen] = '\0';
                buflen++;
            }

            xor_memory(buf, buflen);
            buflen = compress_lz_rle(
                    (unsigned char *) buf,
                    (unsigned char *) buf2,
                    buflen);
            data.data = buf2;
            data.size = buflen;

            if (mysql_row[index_idx] == NULL) {
                fprintf(stderr, "%s: index is NULL\n", argv[0]);
                return 1;
            }
            normalize_number(mysql_row[index_idx]);
            key.data = mysql_row[index_idx];
            key.size = strlen(mysql_row[index_idx]);
            if (key.size != 9) {
                fprintf(stderr, "%s: WARNING: key.size != 9 for '%s'\n",
                        argv[0], (char *) key.data);
            }

            xor_memory(key.data, key.size);
            if ((db_ret = dbp->put(dbp, NULL, &key, &data, 0)) != 0) {
                dbp->err(dbp, db_ret, "DB->put");
                return 1;
            }
        }
        mysql_free_result(mysql_res);
    }

    dbp->close(dbp, 0);
    mysql_close(&mysql);
    return 0;
} /* }}} */

int sys_key_store(DB *dbp, char *sys_key, char *value, int size) /* {{{ */
{
    DBT key, data;
    int db_ret;

    memset(&key,  0, sizeof(key));
    memset(&data, 0, sizeof(data));

    key.data  = sys_key;
    key.size  = MAX_SYS_KEY_SIZE;
    data.data = value;
    data.size = size < 0 ? strlen(value) + 1 : size;
    if ((db_ret = dbp->put(dbp, NULL, &key, &data, 0)) != 0) {
        dbp->err(dbp, db_ret, "DB->put");
        return -1;
    }

    return 0;
} /* }}} */

/* Modeline for ViM {{{
 * vim: set ts=4:
 * vim600: fdm=marker fdl=0 fdc=3:
 * }}} */