static void assert_workdir_matches_tree(
git_repository *repo, const git_oid *id, const char *root, bool recurse)
{
git_object *obj;
git_tree *tree;
size_t i, max_i;
git_buf path = GIT_BUF_INIT;
if (!root)
root = git_repository_workdir(repo);
cl_assert(root);
cl_git_pass(git_object_lookup(&obj, repo, id, GIT_OBJ_ANY));
cl_git_pass(git_object_peel((git_object **)&tree, obj, GIT_OBJ_TREE));
git_object_free(obj);
max_i = git_tree_entrycount(tree);
for (i = 0; i < max_i; ++i) {
const git_tree_entry *te = git_tree_entry_byindex(tree, i);
cl_assert(te);
cl_git_pass(git_buf_joinpath(&path, root, git_tree_entry_name(te)));
switch (git_tree_entry_type(te)) {
case GIT_OBJ_COMMIT:
assert_dir_exists(path.ptr);
break;
case GIT_OBJ_TREE:
assert_dir_exists(path.ptr);
if (recurse)
assert_workdir_matches_tree(
repo, git_tree_entry_id(te), path.ptr, true);
break;
case GIT_OBJ_BLOB:
switch (git_tree_entry_filemode(te)) {
case GIT_FILEMODE_BLOB:
case GIT_FILEMODE_BLOB_EXECUTABLE:
assert_file_exists(path.ptr);
/* because of cross-platform, don't confirm exec bit yet */
break;
case GIT_FILEMODE_LINK:
cl_assert_(git_path_exists(path.ptr), path.ptr);
/* because of cross-platform, don't confirm link yet */
break;
default:
cl_assert(false); /* really?! */
}
break;
default:
cl_assert(false); /* really?!! */
}
}
git_tree_free(tree);
git_buf_free(&path);
}
void RBEIMEvaluation::legacy_read_offline_data_from_files(const std::string & directory_name,
bool read_error_bound_data,
const bool read_binary_data)
{
LOG_SCOPE("legacy_read_offline_data_from_files()", "RBEIMEvaluation");
Parent::legacy_read_offline_data_from_files(directory_name, read_error_bound_data);
// First, find out how many basis functions we had when Greedy terminated
// This was set in RBSystem::read_offline_data_from_files
unsigned int n_bfs = this->get_n_basis_functions();
// The writing mode: DECODE for binary, READ for ASCII
XdrMODE mode = read_binary_data ? DECODE : READ;
// The suffix to use for all the files that are written out
const std::string suffix = read_binary_data ? ".xdr" : ".dat";
// Stream for creating file names
std::ostringstream file_name;
// Read in the interpolation matrix
file_name.str("");
file_name << directory_name << "/interpolation_matrix" << suffix;
assert_file_exists(file_name.str());
Xdr interpolation_matrix_in(file_name.str(), mode);
for(unsigned int i=0; i<n_bfs; i++)
{
for(unsigned int j=0; j<=i; j++)
{
Number value;
interpolation_matrix_in >> value;
interpolation_matrix(i,j) = value;
}
}
interpolation_matrix_in.close();
// Next read in interpolation_points
file_name.str("");
file_name << directory_name << "/interpolation_points" << suffix;
assert_file_exists(file_name.str());
Xdr interpolation_points_in(file_name.str(), mode);
for(unsigned int i=0; i<n_bfs; i++)
{
Real x_val, y_val, z_val = 0.;
interpolation_points_in >> x_val;
if(LIBMESH_DIM >= 2)
interpolation_points_in >> y_val;
if(LIBMESH_DIM >= 3)
interpolation_points_in >> z_val;
Point p(x_val, y_val, z_val);
interpolation_points.push_back(p);
}
interpolation_points_in.close();
// Next read in interpolation_points_var
file_name.str("");
file_name << directory_name << "/interpolation_points_var" << suffix;
assert_file_exists(file_name.str());
Xdr interpolation_points_var_in(file_name.str(), mode);
for(unsigned int i=0; i<n_bfs; i++)
{
unsigned int var;
interpolation_points_var_in >> var;
interpolation_points_var.push_back(var);
}
interpolation_points_var_in.close();
// Read in the elements corresponding to the interpolation points
legacy_read_in_interpolation_points_elem(directory_name);
}
static void full_connect(VALUE self, MYSQL* db) {
// Check to see if we're on the db machine. If so, try to use the socket
VALUE r_host, r_user, r_password, r_path, r_query, r_port;
const char *host = "localhost", *user = "******";
char *database = NULL, *socket = NULL, *password = NULL, *path = NULL;
VALUE encoding = Qnil;
MYSQL *result;
int port = 3306;
unsigned long client_flags = 0;
int encoding_error;
if((r_host = rb_iv_get(self, "@host")) != Qnil) {
host = StringValuePtr(r_host);
}
if((r_user = rb_iv_get(self, "@user")) != Qnil) {
user = StringValuePtr(r_user);
}
if((r_password = rb_iv_get(self, "@password")) != Qnil) {
password = StringValuePtr(r_password);
}
if((r_port = rb_iv_get(self, "@port")) != Qnil) {
port = NUM2INT(r_port);
}
if((r_path = rb_iv_get(self, "@path")) != Qnil) {
path = StringValuePtr(r_path);
database = strtok(path, "/");
}
if (NULL == database || 0 == strlen(database)) {
rb_raise(eConnectionError, "Database must be specified");
}
r_query = rb_iv_get(self, "@query");
if (0 == strcasecmp(host, "localhost")) {
socket = get_uri_option(r_query, "socket");
if (NULL != socket) {
rb_iv_set(self, "@using_socket", Qtrue);
}
}
#ifdef HAVE_MYSQL_SSL_SET
char *ssl_client_key, *ssl_client_cert, *ssl_ca_cert, *ssl_ca_path, *ssl_cipher;
VALUE r_ssl;
if(rb_obj_is_kind_of(r_query, rb_cHash)) {
r_ssl = rb_hash_aref(r_query, rb_str_new2("ssl"));
if(rb_obj_is_kind_of(r_ssl, rb_cHash)) {
ssl_client_key = get_uri_option(r_ssl, "client_key");
ssl_client_cert = get_uri_option(r_ssl, "client_cert");
ssl_ca_cert = get_uri_option(r_ssl, "ca_cert");
ssl_ca_path = get_uri_option(r_ssl, "ca_path");
ssl_cipher = get_uri_option(r_ssl, "cipher");
assert_file_exists(ssl_client_key, "client_key doesn't exist");
assert_file_exists(ssl_client_cert, "client_cert doesn't exist");
assert_file_exists(ssl_ca_cert, "ca_cert doesn't exist");
mysql_ssl_set(db, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
} else if(r_ssl != Qnil) {
rb_raise(rb_eArgError, "ssl must be passed a hash");
}
}
#endif
result = (MYSQL *)mysql_real_connect(
db,
host,
user,
password,
database,
port,
socket,
client_flags
);
if (NULL == result) {
raise_error(self, db, Qnil);
}
#ifdef HAVE_MYSQL_SSL_SET
const char *ssl_cipher_used = mysql_get_ssl_cipher(db);
if (NULL != ssl_cipher_used) {
rb_iv_set(self, "@ssl_cipher", rb_str_new2(ssl_cipher_used));
}
#endif
#ifdef MYSQL_OPT_RECONNECT
my_bool reconnect = 1;
mysql_options(db, MYSQL_OPT_RECONNECT, &reconnect);
#endif
// Set the connections character set
encoding = rb_iv_get(self, "@encoding");
VALUE my_encoding = rb_hash_aref(CONST_GET(mEncoding, "MAP"), encoding);
if(my_encoding != Qnil) {
encoding_error = mysql_set_character_set(db, rb_str_ptr_readonly(my_encoding));
if (0 != encoding_error) {
raise_error(self, db, Qnil);
} else {
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding))));
#endif
rb_iv_set(self, "@my_encoding", my_encoding);
}
} else {
rb_warn("Encoding %s is not a known Ruby encoding for MySQL\n", rb_str_ptr_readonly(encoding));
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
rb_iv_set(self, "@my_encoding", rb_str_new2("utf8"));
}
// Disable sql_auto_is_null
cCommand_execute(Qnil, self, db, rb_str_new2("SET sql_auto_is_null = 0"));
// removed NO_AUTO_VALUE_ON_ZERO because of MySQL bug http://bugs.mysql.com/bug.php?id=42270
// added NO_BACKSLASH_ESCAPES so that backslashes should not be escaped as in other databases
//4.x versions do not support certain session parameters
if(mysql_get_server_version(db) < 50000 ){
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_DIR_IN_CREATE,NO_UNSIGNED_SUBTRACTION'"));
}else{
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'"));
}
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
}
void assert_files_exist(const std::vector<std::string>& file_list) const {
for (auto file : file_list)
assert_file_exists(file);
}
void RBEvaluation::legacy_read_offline_data_from_files(const std::string & directory_name,
bool read_error_bound_data,
const bool read_binary_data)
{
LOG_SCOPE("legacy_read_offline_data_from_files()", "RBEvaluation");
// The reading mode: DECODE for binary, READ for ASCII
XdrMODE mode = read_binary_data ? DECODE : READ;
// The suffix to use for all the files that are written out
const std::string suffix = read_binary_data ? ".xdr" : ".dat";
// The string stream we'll use to make the file names
std::ostringstream file_name;
// First, find out how many basis functions we had when Greedy terminated
unsigned int n_bfs;
{
file_name << directory_name << "/n_bfs" << suffix;
assert_file_exists(file_name.str());
Xdr n_bfs_in(file_name.str(), mode);
n_bfs_in >> n_bfs;
n_bfs_in.close();
}
resize_data_structures(n_bfs, read_error_bound_data);
// Read in the parameter ranges
file_name.str("");
file_name << directory_name << "/parameter_ranges" << suffix;
std::string continuous_param_file_name = file_name.str();
// Read in the discrete parameter values
file_name.str("");
file_name << directory_name << "/discrete_parameter_values" << suffix;
std::string discrete_param_file_name = file_name.str();
read_parameter_data_from_files(continuous_param_file_name,
discrete_param_file_name,
read_binary_data);
// Read in output data in multiple files
for(unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
{
for(unsigned int q_l=0; q_l<rb_theta_expansion->get_n_output_terms(n); q_l++)
{
file_name.str("");
file_name << directory_name << "/output_";
file_name << std::setw(3)
<< std::setprecision(0)
<< std::setfill('0')
<< std::right
<< n;
file_name << "_";
file_name << std::setw(3)
<< std::setprecision(0)
<< std::setfill('0')
<< std::right
<< q_l;
file_name << suffix;
assert_file_exists(file_name.str());
Xdr output_n_in(file_name.str(), mode);
for(unsigned int j=0; j<n_bfs; j++)
{
Number value;
output_n_in >> value;
RB_output_vectors[n][q_l](j) = value;
}
output_n_in.close();
}
}
if(compute_RB_inner_product)
{
// Next read in the inner product matrix
file_name.str("");
file_name << directory_name << "/RB_inner_product_matrix" << suffix;
assert_file_exists(file_name.str());
Xdr RB_inner_product_matrix_in(file_name.str(), mode);
for(unsigned int i=0; i<n_bfs; i++)
{
for(unsigned int j=0; j<n_bfs; j++)
{
Number value;
RB_inner_product_matrix_in >> value;
RB_inner_product_matrix(i,j) = value;
}
}
RB_inner_product_matrix_in.close();
}
// Next read in the Fq vectors
for(unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
{
file_name.str("");
file_name << directory_name << "/RB_F_";
file_name << std::setw(3)
<< std::setprecision(0)
<< std::setfill('0')
<< std::right
<< q_f;
file_name << suffix;
assert_file_exists(file_name.str());
Xdr RB_Fq_f_in(file_name.str(), mode);
for(unsigned int i=0; i<n_bfs; i++)
{
Number value;
RB_Fq_f_in >> value;
RB_Fq_vector[q_f](i) = value;
}
RB_Fq_f_in.close();
}
// Next read in the Aq matrices
for(unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
{
file_name.str("");
file_name << directory_name << "/RB_A_";
file_name << std::setw(3)
<< std::setprecision(0)
<< std::setfill('0')
<< std::right
<< q_a;
file_name << suffix;
assert_file_exists(file_name.str());
Xdr RB_Aq_a_in(file_name.str(), mode);
for(unsigned int i=0; i<n_bfs; i++)
{
for(unsigned int j=0; j<n_bfs; j++)
{
Number value;
RB_Aq_a_in >> value;
RB_Aq_vector[q_a](i,j) = value;
}
}
RB_Aq_a_in.close();
}
if(read_error_bound_data)
{
// Next read in Fq representor norm data
file_name.str("");
file_name << directory_name << "/Fq_innerprods" << suffix;
assert_file_exists(file_name.str());
Xdr RB_Fq_innerprods_in(file_name.str(), mode);
unsigned int Q_f_hat = rb_theta_expansion->get_n_F_terms()*(rb_theta_expansion->get_n_F_terms()+1)/2;
for(unsigned int i=0; i<Q_f_hat; i++)
{
RB_Fq_innerprods_in >> Fq_representor_innerprods[i];
}
RB_Fq_innerprods_in.close();
// Read in output data
for(unsigned int n=0; n<rb_theta_expansion->get_n_outputs(); n++)
{
file_name.str("");
file_name << directory_name << "/output_";
file_name << std::setw(3)
<< std::setprecision(0)
<< std::setfill('0')
<< std::right
<< n;
file_name << "_dual_innerprods" << suffix;
assert_file_exists(file_name.str());
Xdr output_dual_innerprods_in(file_name.str(), mode);
unsigned int Q_l_hat = rb_theta_expansion->get_n_output_terms(n)*(rb_theta_expansion->get_n_output_terms(n)+1)/2;
for(unsigned int q=0; q<Q_l_hat; q++)
{
output_dual_innerprods_in >> output_dual_innerprods[n][q];
}
output_dual_innerprods_in.close();
}
// Next read in Fq_Aq representor norm data
file_name.str("");
file_name << directory_name << "/Fq_Aq_innerprods" << suffix;
assert_file_exists(file_name.str());
Xdr RB_Fq_Aq_innerprods_in(file_name.str(), mode);
for(unsigned int q_f=0; q_f<rb_theta_expansion->get_n_F_terms(); q_f++)
{
for(unsigned int q_a=0; q_a<rb_theta_expansion->get_n_A_terms(); q_a++)
{
for(unsigned int i=0; i<n_bfs; i++)
{
RB_Fq_Aq_innerprods_in >> Fq_Aq_representor_innerprods[q_f][q_a][i];
}
}
}
RB_Fq_Aq_innerprods_in.close();
// Next read in Aq_Aq representor norm data
file_name.str("");
file_name << directory_name << "/Aq_Aq_innerprods" << suffix;
assert_file_exists(file_name.str());
Xdr RB_Aq_Aq_innerprods_in(file_name.str(), mode);
unsigned int Q_a_hat = rb_theta_expansion->get_n_A_terms()*(rb_theta_expansion->get_n_A_terms()+1)/2;
for(unsigned int i=0; i<Q_a_hat; i++)
{
for(unsigned int j=0; j<n_bfs; j++)
{
for(unsigned int l=0; l<n_bfs; l++)
{
RB_Aq_Aq_innerprods_in >> Aq_Aq_representor_innerprods[i][j][l];
}
}
}
RB_Aq_Aq_innerprods_in.close();
}
// Resize basis_functions even if we don't read them in so that
// get_n_bfs() returns the correct value. Initialize the pointers
// to NULL
set_n_basis_functions(n_bfs);
for(unsigned int i=0; i<basis_functions.size(); i++)
{
if(basis_functions[i])
{
basis_functions[i]->clear();
delete basis_functions[i];
}
basis_functions[i] = libmesh_nullptr;
}
}
void RBEvaluation::read_in_vectors_from_multiple_files(System & sys,
std::vector< std::vector<NumericVector<Number> *> * > multiple_vectors,
const std::vector<std::string> & multiple_directory_names,
const std::vector<std::string> & multiple_data_names,
const bool read_binary_vectors)
{
LOG_SCOPE("read_in_vectors_from_multiple_files()", "RBEvaluation");
unsigned int n_files = multiple_vectors.size();
unsigned int n_directories = multiple_directory_names.size();
unsigned int n_data_names = multiple_data_names.size();
libmesh_assert( (n_files == n_directories) && (n_files == n_data_names) );
if (n_files == 0)
return;
// Make sure processors are synced up before we begin
this->comm().barrier();
std::ostringstream file_name;
const std::string basis_function_suffix = (read_binary_vectors ? ".xdr" : ".dat");
struct stat stat_info;
// Assume that all the headers are the same, hence we can just use the first one.
file_name << multiple_directory_names[0] << "/"
<< multiple_data_names[0] << "_header" << basis_function_suffix;
assert_file_exists(file_name.str());
Xdr header_data(file_name.str(),
read_binary_vectors ? DECODE : READ);
// set the version number in header_data from io_version_string
// (same code as in EquationSystemsIO::_read_impl)
std::string io_version_string = get_io_version_string();
std::string::size_type lm_pos = io_version_string.find("libMesh");
std::istringstream iss(io_version_string.substr(lm_pos + 8));
int ver_major = 0, ver_minor = 0, ver_patch = 0;
char dot;
iss >> ver_major >> dot >> ver_minor >> dot >> ver_patch;
header_data.set_version(LIBMESH_VERSION_ID(ver_major, ver_minor, ver_patch));
// We need to call sys.read_header (e.g. to set _written_var_indices properly),
// but by setting the read_header argument to false, it doesn't reinitialize the system
sys.read_header(header_data, io_version_string, /*read_header=*/false, /*read_additional_data=*/false);
// Following EquationSystemsIO::read, we use a temporary numbering (node major)
// before writing out the data
MeshTools::Private::globally_renumber_nodes_and_elements(sys.get_mesh());
for (unsigned int data_index=0; data_index<n_directories; data_index++)
{
std::vector<NumericVector<Number> *> & vectors = *multiple_vectors[data_index];
// Allocate storage for each vector
for (unsigned int i=0; i<vectors.size(); i++)
{
// vectors should all be NULL, otherwise we get a memory leak when
// we create the new vectors in RBEvaluation::read_in_vectors.
if (vectors[i])
libmesh_error_msg("Non-NULL vector passed to read_in_vectors_from_multiple_files");
vectors[i] = NumericVector<Number>::build(sys.comm()).release();
vectors[i]->init (sys.n_dofs(),
sys.n_local_dofs(),
false,
PARALLEL);
}
file_name.str("");
file_name << multiple_directory_names[data_index]
<< "/" << multiple_data_names[data_index]
<< "_data" << basis_function_suffix;
// On processor zero check to be sure the file exists
if (this->processor_id() == 0)
{
int stat_result = stat(file_name.str().c_str(), &stat_info);
if (stat_result != 0)
libmesh_error_msg("File does not exist: " << file_name.str());
}
assert_file_exists(file_name.str());
Xdr vector_data(file_name.str(),
read_binary_vectors ? DECODE : READ);
// The vector_data needs to know which version to read.
vector_data.set_version(LIBMESH_VERSION_ID(ver_major, ver_minor, ver_patch));
sys.read_serialized_vectors (vector_data, vectors);
}
// Undo the temporary renumbering
sys.get_mesh().fix_broken_node_and_element_numbering();
}
void full_connect(VALUE self, MYSQL *db) {
VALUE r_host = rb_iv_get(self, "@host");
const char *host = "localhost";
if (r_host != Qnil) {
host = StringValuePtr(r_host);
}
VALUE r_user = rb_iv_get(self, "@user");
const char *user = "******";
if (r_user != Qnil) {
user = StringValuePtr(r_user);
}
VALUE r_password = rb_iv_get(self, "@password");
char *password = NULL;
if (r_password != Qnil) {
password = StringValuePtr(r_password);
}
VALUE r_port = rb_iv_get(self, "@port");
int port = 3306;
if (r_port != Qnil) {
port = NUM2INT(r_port);
}
VALUE r_path = rb_iv_get(self, "@path");
char *path = NULL;
char *database = NULL;
if (r_path != Qnil) {
path = StringValuePtr(r_path);
database = strtok(path, "/"); // not threadsafe
}
if (!database || !*database) {
rb_raise(eConnectionError, "Database must be specified");
}
VALUE r_query = rb_iv_get(self, "@query");
char *socket = NULL;
// Check to see if we're on the db machine. If so, try to use the socket
if (strcasecmp(host, "localhost") == 0) {
socket = get_uri_option(r_query, "socket");
if (socket) {
rb_iv_set(self, "@using_socket", Qtrue);
}
}
#ifdef HAVE_MYSQL_SSL_SET
char *ssl_client_key, *ssl_client_cert, *ssl_ca_cert, *ssl_ca_path, *ssl_cipher;
VALUE r_ssl;
if (rb_obj_is_kind_of(r_query, rb_cHash)) {
r_ssl = rb_hash_aref(r_query, rb_str_new2("ssl"));
if (rb_obj_is_kind_of(r_ssl, rb_cHash)) {
ssl_client_key = get_uri_option(r_ssl, "client_key");
ssl_client_cert = get_uri_option(r_ssl, "client_cert");
ssl_ca_cert = get_uri_option(r_ssl, "ca_cert");
ssl_ca_path = get_uri_option(r_ssl, "ca_path");
ssl_cipher = get_uri_option(r_ssl, "cipher");
assert_file_exists(ssl_client_key, "client_key doesn't exist");
assert_file_exists(ssl_client_cert, "client_cert doesn't exist");
assert_file_exists(ssl_ca_cert, "ca_cert doesn't exist");
mysql_ssl_set(db, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
}
else if (r_ssl != Qnil) {
rb_raise(rb_eArgError, "ssl must be passed a hash");
}
}
#endif
unsigned long client_flags = 0;
MYSQL *result = mysql_real_connect(
db,
host,
user,
password,
database,
port,
socket,
client_flags
);
if (!result) {
raise_error(self, db, Qnil);
}
#ifdef HAVE_MYSQL_GET_SSL_CIPHER
const char *ssl_cipher_used = mysql_get_ssl_cipher(db);
if (ssl_cipher_used) {
rb_iv_set(self, "@ssl_cipher", rb_str_new2(ssl_cipher_used));
}
#endif
#ifdef MYSQL_OPT_RECONNECT
my_bool reconnect = 1;
mysql_options(db, MYSQL_OPT_RECONNECT, &reconnect);
#endif
// We only support encoding for MySQL versions providing mysql_set_character_set.
// Without this function there are potential issues with mysql_real_escape_string
// since that doesn't take the character set into consideration when setting it
// using a SET CHARACTER SET query. Since we don't want to stimulate these possible
// issues we simply ignore it and assume the user has configured this correctly.
#ifdef HAVE_MYSQL_SET_CHARACTER_SET
// Set the connections character set
VALUE encoding = rb_iv_get(self, "@encoding");
VALUE my_encoding = rb_hash_aref(do_const_get(mEncoding, "MAP"), encoding);
if (my_encoding != Qnil) {
int encoding_error = mysql_set_character_set(db, rb_str_ptr_readonly(my_encoding));
if (encoding_error != 0) {
raise_error(self, db, Qnil);
}
else {
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding))));
#endif
rb_iv_set(self, "@my_encoding", my_encoding);
}
}
else {
rb_warn("Encoding %s is not a known Ruby encoding for MySQL\n", rb_str_ptr_readonly(encoding));
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
rb_iv_set(self, "@my_encoding", rb_str_new2("utf8"));
}
#endif
// Disable sql_auto_is_null
cCommand_execute(Qnil, self, db, rb_str_new2("SET sql_auto_is_null = 0"));
// removed NO_AUTO_VALUE_ON_ZERO because of MySQL bug http://bugs.mysql.com/bug.php?id=42270
// added NO_BACKSLASH_ESCAPES so that backslashes should not be escaped as in other databases
// For really anscient MySQL versions we don't attempt any strictness
#ifdef HAVE_MYSQL_GET_SERVER_VERSION
//4.x versions do not support certain session parameters
if (mysql_get_server_version(db) < 50000) {
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_DIR_IN_CREATE,NO_UNSIGNED_SUBTRACTION'"));
}
else {
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'"));
}
#endif
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
}
