~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzletest.cc

• browse files at revision 2318.5.22
• compare with another revision
• compare with revision 2318.5.22
• download diff
• download tarball
• view history from revision 2318.5.22

Show diffs side-by-side

added

removed

client/drizzletest.cc

475

475

/* For replace_regex */

476

476

void do_get_replace_regex(st_command* command);

477

477

 

478

 

void replace_append_mem(string *ds, const char *val,

479

 

                        int len);

 

478

void replace_append_mem(string& ds, const char *val, int len);

480

479

void replace_append(string *ds, const char *val);

481

480

void replace_append_uint(string *ds, uint32_t val);

482

 

void append_sorted(string* ds, string* ds_input);

 

481

void append_sorted(string& ds, const string& ds_input);

483

482

 

484

483

void handle_error(struct st_command*,

485

484

                  unsigned int err_errno, const char *err_error,

1073

1072

 

1074

1073

*/

1075

1074

 

1076

 

static void cat_file(string* ds, const char* filename)

 

1075

static void cat_file(string& ds, const char* filename)

1077

1076

{

1078

1077

  int fd= internal::my_open(filename, O_RDONLY, MYF(0));

1079

1078

  if (fd < 0)

1090

1089

        /* Add fake newline instead of cr and output the line */

1091

1090

        *p= '\n';

1092

1091

        p++; /* Step past the "fake" newline */

1093

 

        ds->append(start, p-start);

 

1092

        ds.append(start, p - start);

1094

1093

        p++; /* Step past the "fake" newline */

1095

1094

        start= p;

1096

1095

      }

1098

1097

        p++;

1099

1098

    }

1100

1099

    /* Output any chars that might be left */

1101

 

    ds->append(start, p-start);

 

1100

    ds.append(start, p - start);

1102

1101

  }

1103

1102

  internal::my_close(fd, MYF(0));

1104

1103

}

1222

1221

      ds_tmp.append(" --- ");

1223

1222

      ds_tmp.append(filename1);

1224

1223

      ds_tmp.append(" >>>\n");

1225

 

      cat_file(&ds_tmp, filename1);

 

1224

      cat_file(ds_tmp, filename1);

1226

1225

      ds_tmp.append("<<<\n --- ");

1227

1226

      ds_tmp.append(filename1);

1228

1227

      ds_tmp.append(" >>>\n");

1229

 

      cat_file(&ds_tmp, filename2);

 

1228

      cat_file(ds_tmp, filename2);

1230

1229

      ds_tmp.append("<<<<\n");

1231

1230

    }

1232

1231

  }

2638

2637

                     sizeof(cat_file_args)/sizeof(struct command_arg),

2639

2638

                     ' ');

2640

2639

 

2641

 

  cat_file(&ds_res, ds_filename.c_str());

 

2640

  cat_file(ds_res, ds_filename.c_str());

2642

2641

}

2643

2642

 

2644

2643

 

4432

4431

  {

4433

4432

    if (col_idx)

4434

4433

      ds->append("\t");

4435

 

    replace_append_mem(ds, val, (int)len);

 

4434

    replace_append_mem(*ds, val, (int)len);

4436

4435

  }

4437

4436

  else

4438

4437

  {

4439

4438

    ds->append(drizzle_column_name(column));

4440

4439

    ds->append("\t");

4441

 

    replace_append_mem(ds, val, (int)len);

 

4440

    replace_append_mem(*ds, val, (int)len);

4442

4441

    ds->append("\n");

4443

4442

  }

4444

4443

}

4922

4921

  */

4923

4922

  if (!disable_query_log && (flags & QUERY_SEND_FLAG))

4924

4923

  {

4925

 

    replace_append_mem(ds, query, query_len);

 

4924

    replace_append_mem(*ds, query, query_len);

4926

4925

    ds->append(delimiter, delimiter_length);

4927

4926

    ds->append("\n");

4928

4927

  }

4947

4946

  if (display_result_sorted)

4948

4947

  {

4949

4948

    /* Sort the result set and append it to result */

4950

 

    append_sorted(save_ds, &ds_sorted);

 

4949

    append_sorted(*save_ds, ds_sorted);

4951

4950

    ds= save_ds;

4952

4951

  }

4953

4952

 

5907

5906

struct st_replace *init_replace(const char **from, const char **to, uint32_t count,

5908

5907

                                char *word_end_chars);

5909

5908

 

5910

 

void replace_strings_append(struct st_replace *rep, string* ds,

5911

 

                            const char *from, int len);

 

5909

void replace_strings_append(struct st_replace *rep, string& ds, const char *from, int len);

5912

5910

 

5913

5911

st_replace *glob_replace= NULL;

5914

5912

// boost::scoped_ptr<st_replace> glob_replace;

5988

5986

} REPLACE_STRING;

5989

5987

 

5990

5988

 

5991

 

void replace_strings_append(REPLACE *rep, string* ds,

5992

 

                            const char *str, int len)

 

5989

void replace_strings_append(REPLACE *rep, string& ds, const char *str, int len)

5993

5990

{

5994

 

  REPLACE *rep_pos;

5995

5991

  REPLACE_STRING *rep_str;

5996

 

  const char *start, *from;

5997

 

 

5998

 

 

5999

 

  start= from= str;

6000

 

  rep_pos=rep+1;

 

5992

  const char* start= str;

 

5993

  const char* from= str;

 

5994

 

 

5995

  REPLACE* rep_pos=rep+1;

6001

5996

  for (;;)

6002

5997

  {

6003

5998

    /* Loop through states */

6008

6003

    if (!(rep_str = ((REPLACE_STRING*) rep_pos))->replace_string)

6009

6004

    {

6010

6005

      /* No match found */

6011

 

      ds->append(start, from - start - 1);

 

6006

      ds.append(start, from - start - 1);

6012

6007

      return;

6013

6008

    }

6014

6009

 

6015

6010

    /* Append part of original string before replace string */

6016

 

    ds->append(start, (from - rep_str->to_offset) - start);

 

6011

    ds.append(start, (from - rep_str->to_offset) - start);

6017

6012

 

6018

6013

    /* Append replace string */

6019

 

    ds->append(rep_str->replace_string,

6020

 

               strlen(rep_str->replace_string));

 

6014

    ds.append(rep_str->replace_string, strlen(rep_str->replace_string));

6021

6015

 

6022

6016

    if (!*(from-=rep_str->from_offset) && rep_pos->found != 2)

6023

6017

      return;

6915

6909

/* Functions that uses replace and replace_regex */

6916

6910

 

6917

6911

/* Append the string to ds, with optional replace */

6918

 

void replace_append_mem(string *ds, const char *val, int len)

 

6912

void replace_append_mem(string& ds, const char *val, int len)

6919

6913

{

6920

6914

  char *v= strdup(val);

6921

6915

 

6930

6924

    replace_strings_append(glob_replace, ds, v, len);

6931

6925

  }

6932

6926

  else

6933

 

    ds->append(v, len);

 

6927

    ds.append(v, len);

6934

6928

}

6935

6929

 

6936

6930

 

6937

6931

/* Append zero-terminated string to ds, with optional replace */

6938

6932

void replace_append(string *ds, const char *val)

6939

6933

{

6940

 

  replace_append_mem(ds, val, strlen(val));

 

6934

  replace_append_mem(*ds, val, strlen(val));

6941

6935

}

6942

6936

 

6943

6937

/* Append uint32_t to ds, with optional replace */

6945

6939

{

6946

6940

  ostringstream buff;

6947

6941

  buff << val;

6948

 

  replace_append_mem(ds, buff.str().c_str(), buff.str().size());

 

6942

  replace_append_mem(*ds, buff.str().c_str(), buff.str().size());

6949

6943

 

6950

6944

}

6951

6945

 

6964

6958

*/

6965

6959

 

6966

6960

 

6967

 

void append_sorted(string* ds, string *ds_input)

 

6961

void append_sorted(string& ds, const string& ds_input)

6968

6962

{

6969

6963

  priority_queue<string, vector<string>, greater<string> > lines;

6970

6964

 

6971

 

  if (ds_input->empty())

 

6965

  if (ds_input.empty())

6972

6966

    return;  /* No input */

6973

6967

 

6974

 

  unsigned long eol_pos= ds_input->find_first_of('\n', 0);

 

6968

  unsigned long eol_pos= ds_input.find_first_of('\n', 0);

6975

6969

  if (eol_pos == string::npos)

6976

6970

    return; // We should have at least one header here

6977

6971

 

6978

 

  ds->append(ds_input->substr(0, eol_pos+1));

 

6972

  ds.append(ds_input.substr(0, eol_pos+1));

6979

6973

 

6980

6974

  unsigned long start_pos= eol_pos+1;

6981

6975

 

6982

6976

  /* Insert line(s) in array */

6983

6977

  do {

6984

6978

 

6985

 

    eol_pos= ds_input->find_first_of('\n', start_pos);

 

6979

    eol_pos= ds_input.find_first_of('\n', start_pos);

6986

6980

    /* Find end of line */

6987

 

    lines.push(ds_input->substr(start_pos, eol_pos-start_pos+1));

 

6981

    lines.push(ds_input.substr(start_pos, eol_pos-start_pos+1));

6988

6982

    start_pos= eol_pos+1;

6989

6983

 

6990

6984

  } while ( eol_pos != string::npos);

6992

6986

  /* Create new result */

6993

6987

  while (!lines.empty()) 

6994

6988

  {

6995

 

    ds->append(lines.top());

 

6989

    ds.append(lines.top());

6996

6990

    lines.pop();

6997

6991

  }

6998

6992

}

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1