903 lines
28 KiB
Perl
903 lines
28 KiB
Perl
#!/usr/bin/perl -w
|
|
|
|
########################################################################
|
|
# ssqls.pl - Generates ssqls.h, as it defines many near-duplicate
|
|
# functions and classes, varying only in trivial ways.
|
|
#
|
|
# Copyright (c) 1998 by Kevin Atkinson, (c) 1999-2001 by MySQL AB, and
|
|
# (c) 2004-2010 by Educational Technology Resources, Inc. Others may
|
|
# also hold copyrights on code in this file. See the CREDITS.txt file
|
|
# in the top directory of the distribution for details.
|
|
#
|
|
# This file is part of MySQL++.
|
|
#
|
|
# MySQL++ is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU Lesser General Public License as published
|
|
# by the Free Software Foundation; either version 2.1 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# MySQL++ is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
# License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with MySQL++; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
|
# USA
|
|
########################################################################
|
|
|
|
|
|
# This is the limit on the number of SSQLS data members. Higher values
|
|
# will make ssqls.h exponentially larger. This will increase compile
|
|
# times and may even expose limits in your compiler. Increase it only
|
|
# if and as far as you must.
|
|
my $max_data_members = 25;
|
|
|
|
# To make comparisons between floating point values, we subtract them,
|
|
# take the absolute value, and test to see if that delta is under this
|
|
# value. If it is, we call the two values "equal". Change this as fits
|
|
# your need for precision. Note that we express it as a string because
|
|
# we want the value copied literally into ssqls.h, not "preprocessed"
|
|
# by Perl as a floating-point value.
|
|
my $fp_min_delta = "0.00001";
|
|
|
|
|
|
# No user-serviceable parts below.
|
|
|
|
use strict;
|
|
use Getopt::Std;
|
|
|
|
our $opt_f;
|
|
getopts('f:') or die "usage: $0 [-f fields]\n\n";
|
|
$max_data_members = int($opt_f) if defined $opt_f;
|
|
|
|
open (OUT, ">ssqls.h");
|
|
|
|
print OUT << "---";
|
|
|
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
// This file is generated by the Perl script ssqls.pl. Do not modify
|
|
// it directly. Change the script instead.
|
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
#if !defined(MYSQLPP_SSQLS_H)
|
|
#define MYSQLPP_SSQLS_H
|
|
|
|
#include "noexceptions.h"
|
|
#include "sql_types.h"
|
|
|
|
#if !defined(MYSQLPP_SSQLS_COMPATIBLE)
|
|
# error Your compiler is not compatible with the SSQLS feature!
|
|
#endif
|
|
|
|
#include <string>
|
|
|
|
#include <math.h>
|
|
|
|
// Smallest difference between two floating point numbers recognized
|
|
// in making comparisons. If the absolute delta is under this
|
|
// threshold, the two values are considered equal. You can either
|
|
// override this permanently by changing ssqls.pl, or you can do it
|
|
// on a case-by-case basis at compile time by defining this to another
|
|
// value before #including this header.
|
|
#if !defined(MYSQLPP_FP_MIN_DELTA)
|
|
# define MYSQLPP_FP_MIN_DELTA $fp_min_delta
|
|
#endif
|
|
|
|
namespace mysqlpp {
|
|
|
|
enum sql_dummy_type { sql_dummy };
|
|
|
|
#ifdef MYSQLPP_SSQLS_NO_STATICS
|
|
# define MYSQLPP_SSQLS_CONDITIONAL_STATICS(...)
|
|
#else
|
|
# define MYSQLPP_SSQLS_CONDITIONAL_STATICS(...) __VA_ARGS__
|
|
#endif
|
|
|
|
#define MYSQLPP_SSQLS_MAX_MEMBERS $max_data_members
|
|
|
|
---
|
|
|
|
my @types = ("Date", "DateTime", "Time", "String", "std::string");
|
|
foreach my $type (@types) {
|
|
print OUT << "---";
|
|
|
|
inline int sql_cmp(const $type& a, const $type& b)
|
|
{
|
|
return a.compare(b);
|
|
}
|
|
---
|
|
}
|
|
|
|
@types = (
|
|
"signed char", "unsigned char",
|
|
"sql_tinyint", "sql_tinyint_unsigned",
|
|
"signed int", "unsigned",
|
|
"signed short", "unsigned short",
|
|
"signed long", "unsigned long");
|
|
foreach my $type (@types) {
|
|
print OUT << "---";
|
|
|
|
inline int sql_cmp($type a, $type b)
|
|
{
|
|
return a - b;
|
|
}
|
|
---
|
|
}
|
|
|
|
@types = ("longlong", "ulonglong");
|
|
foreach my $type (@types) {
|
|
print OUT << "---";
|
|
|
|
inline int sql_cmp($type a, $type b)
|
|
{
|
|
if (a == b) return 0;
|
|
if (a < b) return -1;
|
|
return 1;
|
|
}
|
|
---
|
|
}
|
|
|
|
@types = ("double", "float");
|
|
foreach my $type (@types) {
|
|
print OUT << "---";
|
|
|
|
inline int sql_cmp($type a, $type b)
|
|
{
|
|
if (fabs(a - b) < MYSQLPP_FP_MIN_DELTA) return 0;
|
|
if (a < b) return -1;
|
|
return 1;
|
|
}
|
|
---
|
|
}
|
|
|
|
print OUT << "---";
|
|
|
|
template <typename T>
|
|
inline int sql_cmp(const mysqlpp::Null<T>& a, const mysqlpp::Null<T>& b)
|
|
{
|
|
if (a == b) return 0;
|
|
if (a < b) return -1;
|
|
return 1;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------
|
|
// Begin Mandatory Compare
|
|
// ---------------------------------------------------
|
|
|
|
#define sql_compare_define(NAME) \\
|
|
bool operator == (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) == 0;} \\
|
|
bool operator != (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) != 0;} \\
|
|
bool operator > (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) > 0;} \\
|
|
bool operator < (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) < 0;} \\
|
|
bool operator >= (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) >= 0;} \\
|
|
bool operator <= (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other) <= 0;} \\
|
|
int cmp (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other);} \\
|
|
int compare (const NAME &other) const \\
|
|
{return sql_compare_##NAME<mysqlpp::sql_dummy>(*this,other);}
|
|
---
|
|
|
|
my ($parm0, $parm1);
|
|
|
|
foreach my $j (1..$max_data_members) {
|
|
$parm0 .= "T$j, C$j";
|
|
$parm0 .= ", " unless $j == $max_data_members;
|
|
$parm1 .= "C$j";
|
|
$parm1 .= ", " unless $j == $max_data_members;
|
|
}
|
|
|
|
print OUT << "---";
|
|
|
|
#define sql_compare_define_0(NAME, $parm0)
|
|
|
|
#define sql_construct_define_0(NAME, $parm0)
|
|
|
|
#define sql_COMPARE__0(NAME, $parm1)
|
|
|
|
#define sql_compare_type_def_0(NAME, WHAT, NUM) \\
|
|
sql_compare_type_def_##NUM(NAME, WHAT, NUM)
|
|
|
|
#define sql_compare_type_defe_0(NAME, WHAT, NUM) \\
|
|
sql_compare_type_defe_##NUM(NAME, WHAT, NUM)
|
|
|
|
// ---------------------------------------------------
|
|
// End Mandatory Compare
|
|
// ---------------------------------------------------
|
|
---
|
|
|
|
|
|
foreach my $i (1..$max_data_members) {
|
|
my ($compr, $define, $compp, $set, $parm2);
|
|
|
|
$compr = ""; $parm2 = ""; $define = "";
|
|
$compr = " int cmp; \\\n" unless $i == 1;
|
|
$compp = "";
|
|
$set = "";
|
|
|
|
foreach my $j (1..$i) {
|
|
if ($j != $i) {
|
|
$compr .= " cmp = mysqlpp::sql_cmp(x.C$j , y.C$j ); \\\n";
|
|
$compr .= " if (cmp) return cmp; \\\n";
|
|
}
|
|
|
|
$compr .= " return mysqlpp::sql_cmp(x.C$j , y.C$j );" if $j == $i;
|
|
$parm2 .= "const T$j &p$j";
|
|
$parm2 .= ", " unless $j == $i;
|
|
$define.= "C$j (p$j)";
|
|
$define.= ", " unless $j == $i;
|
|
$set .= " C$j = p$j;\\\n";
|
|
$compp .= "true";
|
|
$compp .= ", " unless $j == $i;
|
|
}
|
|
print OUT << "---";
|
|
|
|
// ---------------------------------------------------
|
|
// Begin Compare $i
|
|
// ---------------------------------------------------
|
|
|
|
#define sql_compare_define_$i(NAME, $parm0) \\
|
|
NAME($parm2) : $define, table_override_(0) {} \\
|
|
void set($parm2) { \\
|
|
table_override_ = 0; \\
|
|
$set \\
|
|
} \\
|
|
sql_compare_define(NAME)
|
|
|
|
#define sql_construct_define_$i(NAME, $parm0) \\
|
|
void set($parm2) { \\
|
|
table_override_ = 0; \\
|
|
$set \\
|
|
} \\
|
|
NAME($parm2) : $define, table_override_(0) {}
|
|
|
|
#define sql_compare_type_def_$i(NAME, WHAT, NUM) \\
|
|
return WHAT##_list(d, m, $compp)
|
|
|
|
#define sql_compare_type_defe_$i(NAME, WHAT, NUM) \\
|
|
return WHAT##_list(d, c, m, $compp)
|
|
|
|
#define sql_COMPARE__$i(NAME, $parm1) \\
|
|
template <mysqlpp::sql_dummy_type dummy> \\
|
|
int sql_compare_##NAME(const NAME &x, const NAME &y) { \\
|
|
$compr \\
|
|
} \\
|
|
template <mysqlpp::sql_dummy_type dummy> \\
|
|
int compare (const NAME &x, const NAME &y) { \\
|
|
$compr \\
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// End Compare $i
|
|
// ---------------------------------------------------
|
|
|
|
---
|
|
}
|
|
|
|
|
|
foreach my $i (1..$max_data_members) {
|
|
my $create_bool = "";
|
|
my $create_list = "";
|
|
my $cus_equal_list = "";
|
|
my $cus_field_list = "";
|
|
my $cusparms1 = "";
|
|
my $cusparms11 = "";
|
|
my $cusparms2 = "";
|
|
my $cusparms22 = "";
|
|
my $cusparmsv = "";
|
|
my $defs = "";
|
|
my $enums = "";
|
|
my $equal_list = "";
|
|
my $field_list = "";
|
|
my $names = "";
|
|
my $parmc = "";
|
|
my $parmC = "";
|
|
my $parm_complete = "";
|
|
my $parm_simple = "";
|
|
my $parm_simple2c = "";
|
|
my $parm_simple2c_b = "";
|
|
my $parm_simple_b = "";
|
|
my $popul = "";
|
|
my $value_list = "";
|
|
my $value_list_cus = "";
|
|
|
|
foreach my $j (1 .. $i) {
|
|
$parm_complete .= "T$j, I$j, N$j";
|
|
$parm_complete .= ", " unless $j == $i;
|
|
$parm_simple .= "T$j, I$j";
|
|
$parm_simple .= ", " unless $j == $i;
|
|
$parm_simple2c .= "T$j, I$j, #I$j";
|
|
$parm_simple2c .= ", " unless $j == $i;
|
|
$parm_simple_b .= "T$j, I$j";
|
|
$parm_simple_b .= ", " unless $j == $i;
|
|
$parm_simple2c_b .= "T$j, I$j";
|
|
$parm_simple2c_b .= ", " unless $j == $i;
|
|
|
|
$defs .= " T$j I$j;";
|
|
$defs .= "\n" unless $j == $i;
|
|
|
|
$popul .= " s->I$j = row[N$j].conv(T$j());";
|
|
$popul .= "\n" unless $j == $i;
|
|
|
|
$names .= " N$j ";
|
|
$names .= ",\n" unless $j == $i;
|
|
$enums .= " NAME##_##I$j";
|
|
$enums .= ",\n" unless $j == $i;
|
|
|
|
$field_list .= " s << obj.manip << '`' << obj.obj->names[".($j-1)."] << '`'";
|
|
$field_list .= " << obj.delim;\n" unless $j == $i;
|
|
|
|
$value_list .= " s << obj.manip << obj.obj->I$j";
|
|
$value_list .= " << obj.delim;\n" unless $j == $i;
|
|
|
|
$create_bool .= " if (i$j) (*include)[".($j-1)."]=true;\n";
|
|
|
|
$create_list .= " if (i$j == NAME##_NULL) return;\n" unless $i == 1;
|
|
$create_list .= " (*include)[i$j]=true;\n";
|
|
|
|
$value_list_cus .= " if ((*obj.include)[".($j-1)."]) { \n";
|
|
$value_list_cus .= " if (before) s << obj.delim;\n" unless $j == 1;
|
|
$value_list_cus .= " s << obj.manip << obj.obj->I$j;\n";
|
|
$value_list_cus .= " before = true; \n" unless $j == $i;
|
|
$value_list_cus .= " } \n";
|
|
|
|
$cus_field_list .= " if ((*obj.include)[".($j-1)."]) { \n";
|
|
$cus_field_list .= " if (before) s << obj.delim;\n" unless $j == 1;
|
|
$cus_field_list .= " s << obj.manip << '`' << obj.obj->names[".($j-1)."] << '`';\n";
|
|
$cus_field_list .= " before = true; \n" unless $j == $i;
|
|
$cus_field_list .= " } \n";
|
|
|
|
$cus_equal_list .= " if ((*obj.include)[".($j-1)."]) { \n";
|
|
$cus_equal_list .= " if (before) s << obj.delim;\n" unless $j == 1;
|
|
$cus_equal_list .= " s << '`' << obj.obj->names[".($j-1)."] << '`' << obj.comp";
|
|
$cus_equal_list .= " << obj.manip << obj.obj->I$j;\n";
|
|
$cus_equal_list .= " before = true; \n" unless $j == $i;
|
|
$cus_equal_list .= " } \n";
|
|
|
|
$equal_list .= " s << '`' << obj.obj->names[".($j-1)."] << '`' << obj.comp";
|
|
$equal_list .= " << obj.manip << obj.obj->I$j";
|
|
$equal_list .= " << obj.delim;\n" unless $j == $i;
|
|
|
|
$cusparms1 .= "bool i$j" if $j == 1;
|
|
$cusparms1 .= "bool i$j = false" unless $j == 1;
|
|
$cusparms1 .= ", " unless $j == $i;
|
|
$cusparms11 .= "bool i$j" ;
|
|
$cusparms11 .= ", " unless $j == $i;
|
|
$cusparms2 .= "NAME##_enum i$j" if $j == 1;
|
|
$cusparms2 .= "NAME##_enum i$j = NAME##_NULL" unless $j == 1;
|
|
$cusparms2 .= ", " unless $j == $i;
|
|
$cusparms22 .= "NAME##_enum i$j";
|
|
$cusparms22 .= ", " unless $j == $i;
|
|
$cusparmsv .= "i$j";
|
|
$cusparmsv .= ", " unless $j == $i;
|
|
|
|
$parmC .= "T$j, I$j";
|
|
$parmC .= ", " unless $j == $max_data_members;
|
|
$parmc .= "I$j";
|
|
$parmc .= ", " unless $j == $max_data_members;
|
|
}
|
|
|
|
foreach my $j ($i + 1 .. $max_data_members) {
|
|
$parmC .= "0, 0";
|
|
$parmC .= ", " unless $j == $max_data_members;
|
|
$parmc .= "0";
|
|
$parmc .= ", " unless $j == $max_data_members;
|
|
}
|
|
|
|
print OUT << "---";
|
|
// ---------------------------------------------------
|
|
// Begin Create $i
|
|
// ---------------------------------------------------
|
|
---
|
|
my $out = <<"---";
|
|
#define sql_create_complete_$i(NAME, CMP, CONTR, $parm_complete)
|
|
struct NAME;
|
|
|
|
enum NAME##_enum {
|
|
$enums
|
|
,NAME##_NULL
|
|
};
|
|
|
|
template <class Manip>
|
|
class NAME##_value_list {
|
|
public:
|
|
const NAME* obj;
|
|
const char* delim;
|
|
Manip manip;
|
|
public:
|
|
NAME##_value_list (const NAME* o, const char* d, Manip m) :
|
|
obj(o), delim(d), manip(m) { }
|
|
};
|
|
|
|
template <class Manip>
|
|
class NAME##_##field_list {
|
|
public:
|
|
const NAME* obj;
|
|
const char* delim;
|
|
Manip manip;
|
|
public:
|
|
NAME##_field_list (const NAME* o, const char* d, Manip m) :
|
|
obj(o), delim(d), manip(m) { }
|
|
};
|
|
|
|
template <class Manip>
|
|
class NAME##_equal_list {
|
|
public:
|
|
const NAME* obj;
|
|
const char* delim;
|
|
const char* comp;
|
|
Manip manip;
|
|
public:
|
|
NAME##_equal_list (const NAME* o, const char* d, const char* c, Manip m) :
|
|
obj(o), delim(d), comp(c), manip(m) { }
|
|
};
|
|
|
|
template <class Manip>
|
|
class NAME##_cus_value_list {
|
|
public:
|
|
const NAME* obj;
|
|
std::vector<bool> *include;
|
|
bool del_vector;
|
|
const char* delim;
|
|
Manip manip;
|
|
public:
|
|
~NAME##_cus_value_list () {if (del_vector) delete include;}
|
|
NAME##_cus_value_list (const NAME* o, const char* d, Manip m, $cusparms11);
|
|
NAME##_cus_value_list (const NAME* o, const char* d, Manip m, $cusparms22);
|
|
NAME##_cus_value_list (const NAME* o, const char* d, Manip m ,std::vector<bool>* i) :
|
|
obj(o), include(i), del_vector(false), delim(d), manip(m) { }
|
|
};
|
|
|
|
template <class Manip>
|
|
class NAME##_cus_field_list {
|
|
public:
|
|
const NAME* obj;
|
|
std::vector<bool> *include;
|
|
bool del_vector;
|
|
const char* delim;
|
|
Manip manip;
|
|
public:
|
|
~NAME##_cus_field_list () {if (del_vector) delete include;}
|
|
NAME##_cus_field_list (const NAME* o, const char* d, Manip m, $cusparms11);
|
|
NAME##_cus_field_list (const NAME* o, const char* d, Manip m, $cusparms22);
|
|
NAME##_cus_field_list (const NAME* o, const char* d, Manip m, std::vector<bool> *i) :
|
|
obj(o), include(i), del_vector(false), delim(d), manip(m) { }
|
|
};
|
|
|
|
template <class Manip>
|
|
class NAME##_cus_equal_list {
|
|
public:
|
|
const NAME* obj;
|
|
std::vector<bool> *include;
|
|
bool del_vector;
|
|
const char* delim;
|
|
const char* comp;
|
|
Manip manip;
|
|
public:
|
|
~NAME##_##cus_equal_list () {if (del_vector) delete include;}
|
|
NAME##_##cus_equal_list (const NAME* o, const char* d, const char* c, Manip m, $cusparms11);
|
|
NAME##_##cus_equal_list (const NAME* o, const char* d, const char* c, Manip m, $cusparms22);
|
|
NAME##_##cus_equal_list (const NAME* o, const char* d, const char* c, Manip m, std::vector<bool> *i) :
|
|
obj(o), include(i), del_vector(false), delim(d), comp(c), manip(m) { }
|
|
};
|
|
|
|
template <mysqlpp::sql_dummy_type dummy> int sql_compare_##NAME(const NAME&, const NAME&);
|
|
|
|
struct NAME {
|
|
$defs
|
|
NAME() : table_override_(0) { }
|
|
NAME(const mysqlpp::Row& row);
|
|
void set(const mysqlpp::Row &row);
|
|
sql_compare_define_##CMP(NAME, $parmC)
|
|
sql_construct_define_##CONTR(NAME, $parmC)
|
|
static const char* names[];
|
|
static void table(const char* t) { table_ = t; }
|
|
const char* const table() const
|
|
{ return table_override_ ? table_override_ : NAME::table_; }
|
|
void instance_table(const char* t) { table_override_ = t; }
|
|
|
|
NAME##_value_list<mysqlpp::quote_type0> value_list() const {
|
|
return value_list(",", mysqlpp::quote);}
|
|
NAME##_value_list<mysqlpp::quote_type0> value_list(const char* d) const {
|
|
return value_list(d, mysqlpp::quote);}
|
|
template <class Manip>
|
|
NAME##_value_list<Manip> value_list(const char* d, Manip m) const;
|
|
|
|
NAME##_field_list<mysqlpp::do_nothing_type0> field_list() const {
|
|
return field_list(",", mysqlpp::do_nothing);}
|
|
NAME##_field_list<mysqlpp::do_nothing_type0> field_list(const char* d) const {
|
|
return field_list(d, mysqlpp::do_nothing);}
|
|
template <class Manip>
|
|
NAME##_field_list<Manip> field_list(const char* d, Manip m) const;
|
|
|
|
NAME##_equal_list<mysqlpp::quote_type0> equal_list(const char* d = ",",
|
|
const char* c = " = ") const
|
|
{ return equal_list(d, c, mysqlpp::quote); }
|
|
template <class Manip>
|
|
NAME##_equal_list<Manip> equal_list(const char* d, const char* c, Manip m) const;
|
|
|
|
/* cus_data */
|
|
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list($cusparms1) const
|
|
{ return value_list(",", mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list($cusparms2) const
|
|
{ return value_list(",", mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list(std::vector<bool> *i) const
|
|
{ return value_list(",", mysqlpp::quote, i); }
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list(mysqlpp::sql_cmp_type sc) const
|
|
{ return value_list(",", mysqlpp::quote, sc); }
|
|
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char* d, $cusparms1) const
|
|
{ return value_list(d, mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char* d, $cusparms2) const
|
|
{ return value_list(d, mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char* d,
|
|
std::vector<bool> *i) const
|
|
{ return value_list(d, mysqlpp::quote, i); }
|
|
NAME##_cus_value_list<mysqlpp::quote_type0> value_list(const char* d,
|
|
mysqlpp::sql_cmp_type sc) const
|
|
{ return value_list(d, mysqlpp::quote, sc); }
|
|
|
|
template <class Manip>
|
|
NAME##_cus_value_list<Manip> value_list(const char* d, Manip m,
|
|
$cusparms1) const;
|
|
template <class Manip>
|
|
NAME##_cus_value_list<Manip> value_list(const char* d, Manip m,
|
|
$cusparms2) const;
|
|
template <class Manip>
|
|
NAME##_cus_value_list<Manip> value_list(const char* d, Manip m,
|
|
std::vector<bool>* i) const;
|
|
template <class Manip>
|
|
NAME##_cus_value_list<Manip> value_list(const char* d, Manip m,
|
|
mysqlpp::sql_cmp_type sc) const;
|
|
/* cus field */
|
|
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list($cusparms1) const
|
|
{ return field_list(",", mysqlpp::do_nothing, $cusparmsv); }
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list($cusparms2) const
|
|
{ return field_list(",", mysqlpp::do_nothing, $cusparmsv); }
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(std::vector<bool> *i) const
|
|
{ return field_list(",", mysqlpp::do_nothing, i); }
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(mysqlpp::sql_cmp_type sc) const
|
|
{ return field_list(",", mysqlpp::do_nothing, sc); }
|
|
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char* d,
|
|
$cusparms1) const
|
|
{ return field_list(d, mysqlpp::do_nothing, $cusparmsv); }
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char* d,
|
|
$cusparms2) const
|
|
{ return field_list(d, mysqlpp::do_nothing, $cusparmsv); }
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char* d,
|
|
std::vector<bool>* i) const
|
|
{ return field_list(d, mysqlpp::do_nothing, i); }
|
|
NAME##_cus_field_list<mysqlpp::do_nothing_type0> field_list(const char* d,
|
|
mysqlpp::sql_cmp_type sc) const
|
|
{ return field_list(d, mysqlpp::do_nothing, sc); }
|
|
|
|
template <class Manip>
|
|
NAME##_cus_field_list<Manip> field_list(const char* d, Manip m,
|
|
$cusparms1) const;
|
|
template <class Manip>
|
|
NAME##_cus_field_list<Manip> field_list(const char* d, Manip m,
|
|
$cusparms2) const;
|
|
template <class Manip>
|
|
NAME##_cus_field_list<Manip> field_list(const char* d, Manip m,
|
|
std::vector<bool> *i) const;
|
|
template <class Manip>
|
|
NAME##_cus_field_list<Manip> field_list(const char* d, Manip m,
|
|
mysqlpp::sql_cmp_type sc) const;
|
|
|
|
/* cus equal */
|
|
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list($cusparms1) const
|
|
{ return equal_list(",", " = ", mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list($cusparms2) const
|
|
{ return equal_list(",", " = ", mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(std::vector<bool>* i) const
|
|
{ return equal_list(",", " = ", mysqlpp::quote, i); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(mysqlpp::sql_cmp_type sc) const
|
|
{ return equal_list(",", " = ", mysqlpp::quote, sc); }
|
|
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d, $cusparms1) const
|
|
{ return equal_list(d, " = ", mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d, $cusparms2) const
|
|
{ return equal_list(d, " = ", mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d,
|
|
std::vector<bool> *i) const
|
|
{ return equal_list(d, " = ", mysqlpp::quote, i); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d,
|
|
mysqlpp::sql_cmp_type sc) const
|
|
{ return equal_list(d, " = ", mysqlpp::quote, sc); }
|
|
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d, const char* c,
|
|
$cusparms1) const
|
|
{ return equal_list(d, c, mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d, const char* c,
|
|
$cusparms2) const
|
|
{ return equal_list(d, c, mysqlpp::quote, $cusparmsv); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d, const char* c,
|
|
std::vector<bool> *i) const
|
|
{ return equal_list(d, c, mysqlpp::quote, i); }
|
|
NAME##_cus_equal_list<mysqlpp::quote_type0> equal_list(const char* d, const char* c,
|
|
mysqlpp::sql_cmp_type sc) const
|
|
{ return equal_list(d, c, mysqlpp::quote, sc); }
|
|
|
|
template <class Manip>
|
|
NAME##_cus_equal_list<Manip> equal_list(const char* d, const char* c, Manip m,
|
|
$cusparms1) const;
|
|
template <class Manip>
|
|
NAME##_cus_equal_list<Manip> equal_list(const char* d, const char* c, Manip m,
|
|
$cusparms2) const;
|
|
template <class Manip>
|
|
NAME##_cus_equal_list<Manip> equal_list(const char* d, const char* c, Manip m,
|
|
std::vector<bool> *i) const;
|
|
template <class Manip>
|
|
NAME##_cus_equal_list<Manip> equal_list(const char* d, const char* c, Manip m,
|
|
mysqlpp::sql_cmp_type sc) const;
|
|
|
|
private:
|
|
static const char* table_;
|
|
const char* table_override_;
|
|
};
|
|
MYSQLPP_SSQLS_CONDITIONAL_STATICS(
|
|
const char* NAME::names[] = {
|
|
$names
|
|
};
|
|
const char* NAME::table_ = #NAME;
|
|
)
|
|
|
|
template <class Manip>
|
|
NAME##_cus_value_list<Manip>::NAME##_cus_value_list
|
|
(const NAME* o, const char* d, Manip m, $cusparms11)
|
|
{
|
|
delim = d;
|
|
manip = m;
|
|
del_vector = true;
|
|
obj = o;
|
|
include = new std::vector<bool>($i, false);
|
|
$create_bool
|
|
}
|
|
|
|
template <class Manip>
|
|
NAME##_cus_value_list<Manip>::NAME##_cus_value_list
|
|
(const NAME* o, const char* d, Manip m, $cusparms22)
|
|
{
|
|
delim = d;
|
|
manip = m;
|
|
del_vector = true;
|
|
obj = o;
|
|
include = new std::vector<bool>($i, false);
|
|
$create_list
|
|
}
|
|
|
|
template <class Manip>
|
|
NAME##_cus_field_list<Manip>::NAME##_cus_field_list
|
|
(const NAME* o, const char* d, Manip m, $cusparms11)
|
|
{
|
|
delim = d;
|
|
manip = m;
|
|
del_vector = true;
|
|
obj = o;
|
|
include = new std::vector<bool>($i, false);
|
|
$create_bool
|
|
}
|
|
|
|
template <class Manip>
|
|
NAME##_cus_field_list<Manip>::NAME##_cus_field_list
|
|
(const NAME* o, const char* d, Manip m, $cusparms22)
|
|
{
|
|
delim = d;
|
|
manip = m;
|
|
del_vector = true;
|
|
obj = o;
|
|
include = new std::vector<bool>($i, false);
|
|
$create_list
|
|
}
|
|
|
|
template <class Manip>
|
|
NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
|
|
(const NAME* o, const char* d, const char* c, Manip m, $cusparms11)
|
|
{
|
|
delim = d;
|
|
comp = c;
|
|
manip = m;
|
|
del_vector = true;
|
|
obj = o;
|
|
include = new std::vector<bool>($i, false);
|
|
$create_bool
|
|
}
|
|
|
|
template <class Manip>
|
|
NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
|
|
(const NAME* o, const char* d, const char* c, Manip m, $cusparms22)
|
|
{
|
|
delim = d;
|
|
comp = c;
|
|
manip = m;
|
|
del_vector = true;
|
|
obj = o;
|
|
include = new std::vector<bool>($i, false);
|
|
$create_list
|
|
}
|
|
|
|
template <class Manip>
|
|
std::ostream& operator <<(std::ostream& s, const NAME##_value_list<Manip>& obj)
|
|
{
|
|
$value_list;
|
|
return s;
|
|
}
|
|
|
|
template <class Manip>
|
|
std::ostream& operator <<(std::ostream& s, const NAME##_field_list<Manip>& obj)
|
|
{
|
|
$field_list;
|
|
return s;
|
|
}
|
|
|
|
template <class Manip>
|
|
std::ostream& operator <<(std::ostream& s, const NAME##_equal_list<Manip>& obj)
|
|
{
|
|
$equal_list;
|
|
return s;
|
|
}
|
|
|
|
template <class Manip>
|
|
std::ostream& operator <<(std::ostream& s, const NAME##_cus_value_list<Manip>& obj)
|
|
{
|
|
bool before = false;
|
|
$value_list_cus
|
|
return s;
|
|
}
|
|
|
|
template <class Manip>
|
|
std::ostream& operator <<(std::ostream& s, const NAME##_cus_field_list<Manip>& obj)
|
|
{
|
|
bool before = false;
|
|
$cus_field_list
|
|
return s;
|
|
}
|
|
|
|
template <class Manip>
|
|
std::ostream& operator <<(std::ostream& s, const NAME##_cus_equal_list<Manip>& obj)
|
|
{
|
|
bool before = false;
|
|
$cus_equal_list
|
|
return s;
|
|
}
|
|
|
|
template <class Manip>
|
|
inline NAME##_value_list<Manip> NAME::value_list(const char* d, Manip m) const
|
|
{ return NAME##_value_list<Manip> (this, d, m); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_field_list<Manip> NAME::field_list(const char* d, Manip m) const
|
|
{ return NAME##_field_list<Manip> (this, d, m); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_equal_list<Manip> NAME::equal_list(const char* d, const char* c, Manip m) const
|
|
{ return NAME##_equal_list<Manip> (this, d, c, m); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_value_list<Manip> NAME::value_list(const char* d, Manip m,
|
|
$cusparms11) const
|
|
{ return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_field_list<Manip> NAME::field_list(const char* d, Manip m,
|
|
$cusparms11) const
|
|
{ return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char* d, const char* c, Manip m,
|
|
$cusparms11) const
|
|
{ return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_value_list<Manip> NAME::value_list(const char* d, Manip m,
|
|
$cusparms22) const
|
|
{ return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_field_list<Manip> NAME::field_list(const char* d, Manip m,
|
|
$cusparms22) const
|
|
{ return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char* d, const char* c, Manip m,
|
|
$cusparms22) const
|
|
{ return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_value_list<Manip> NAME::value_list(const char* d, Manip m,
|
|
std::vector<bool> *i) const
|
|
{ return NAME##_cus_value_list<Manip> (this, d, m, i); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_field_list<Manip> NAME::field_list(const char* d, Manip m,
|
|
std::vector<bool> *i) const
|
|
{ return NAME##_cus_field_list<Manip> (this, d, m, i); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_equal_list<Manip> NAME::equal_list(const char* d, const char* c, Manip m,
|
|
std::vector<bool> *i) const
|
|
{ return NAME##_cus_equal_list<Manip> (this, d, c, m, i); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_value_list<Manip>
|
|
NAME::value_list(const char* d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const
|
|
{ sql_compare_type_def_##CMP(NAME, value, NUM); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_field_list<Manip>
|
|
NAME::field_list(const char* d, Manip m, mysqlpp::sql_cmp_type /*sc*/) const
|
|
{ sql_compare_type_def_##CMP(NAME, field, NUM); }
|
|
|
|
template <class Manip>
|
|
inline NAME##_cus_equal_list<Manip>
|
|
NAME::equal_list(const char* d, const char* c, Manip m, mysqlpp::sql_cmp_type /*sc*/) const
|
|
{ sql_compare_type_defe_##CMP(NAME, equal, NUM); }
|
|
|
|
template <mysqlpp::sql_dummy_type dummy>
|
|
void populate_##NAME(NAME *s, const mysqlpp::Row &row)
|
|
{
|
|
mysqlpp::NoExceptions ignore_schema_mismatches(row);
|
|
$popul
|
|
}
|
|
|
|
inline NAME::NAME(const mysqlpp::Row& row) :
|
|
table_override_(0)
|
|
{ populate_##NAME<mysqlpp::sql_dummy>(this, row); }
|
|
inline void NAME::set(const mysqlpp::Row& row)
|
|
{
|
|
table_override_ = 0;
|
|
populate_##NAME<mysqlpp::sql_dummy>(this, row);
|
|
}
|
|
|
|
sql_COMPARE__##CMP(NAME, $parmc )
|
|
|
|
---
|
|
print OUT &prepare($out);
|
|
|
|
#
|
|
# short cut defs
|
|
#
|
|
|
|
print OUT << "---";
|
|
#define sql_create_$i(NAME, CMP, CONTR, $parm_simple) \\
|
|
sql_create_complete_$i(NAME, CMP, CONTR, $parm_simple2c) \\
|
|
|
|
// ---------------------------------------------------
|
|
// End Create $i
|
|
// ---------------------------------------------------
|
|
|
|
---
|
|
|
|
}
|
|
|
|
|
|
print OUT << "---";
|
|
|
|
} // end namespace mysqlpp
|
|
|
|
#endif // !defined(MYSQLPP_SSQLS_H)
|
|
|
|
---
|
|
|
|
|
|
sub prepare {
|
|
local $_ = $_[0];
|
|
s/\n+$//;
|
|
s/\n[\n ]*\n/\n/g;
|
|
s/\n+/\\\n/g;
|
|
$_ .= "\n\n";
|
|
return $_;
|
|
}
|
|
|