2018-03-23 20:26:57 +01:00
/*
* This file is a part of morm
* and is distributed under the 2 - Clause BSD licence .
* Author : Tomasz Sowa < t . sowa @ ttmath . org >
*/
/*
2023-02-26 18:28:16 +01:00
* Copyright ( c ) 2018 - 2023 , Tomasz Sowa
2018-03-23 20:26:57 +01:00
* All rights reserved .
*
* Redistribution and use in source and binary forms , with or without
* modification , are permitted provided that the following conditions are met :
*
* 1. Redistributions of source code must retain the above copyright notice ,
* this list of conditions and the following disclaimer .
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice , this list of conditions and the following disclaimer in the
* documentation and / or other materials provided with the distribution .
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS " AS IS "
* AND ANY EXPRESS OR IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED . IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT , INDIRECT , INCIDENTAL , SPECIAL , EXEMPLARY , OR
* CONSEQUENTIAL DAMAGES ( INCLUDING , BUT NOT LIMITED TO , PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE , DATA , OR PROFITS ; OR BUSINESS
* INTERRUPTION ) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY , WHETHER IN
* CONTRACT , STRICT LIABILITY , OR TORT ( INCLUDING NEGLIGENCE OR OTHERWISE )
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE , EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE .
*
*/
# include "baseexpression.h"
# include "morm_types.h"
# include "model.h"
# include "utf8/utf8.h"
namespace morm
{
BaseExpression : : BaseExpression ( )
{
2022-05-31 01:45:27 +02:00
/*
* may it would be better for the ModelConnector / JSONConnector / PostgreSQLConnector to provide one scratch buffer ?
*/
scratch_buffer = & scratch_buffer_local ;
2019-05-31 20:28:09 +02:00
clear ( ) ;
2018-03-23 20:26:57 +01:00
}
2023-04-12 17:20:29 +02:00
2018-03-23 20:26:57 +01:00
BaseExpression : : ~ BaseExpression ( )
{
}
2019-05-31 20:28:09 +02:00
void BaseExpression : : clear ( )
{
out_stream = nullptr ;
is_first_field = false ;
work_mode = 0 ;
2023-04-12 17:20:29 +02:00
output_type = 0 ;
2019-05-31 20:28:09 +02:00
use_prefix = false ;
}
2018-03-23 20:26:57 +01:00
void BaseExpression : : set_work_mode ( int work_mode )
{
this - > work_mode = work_mode ;
}
2019-03-26 19:34:07 +01:00
int BaseExpression : : get_work_mode ( )
{
return work_mode ;
}
2023-04-12 17:20:29 +02:00
void BaseExpression : : set_output_type ( int output_type )
{
this - > output_type = output_type ;
}
int BaseExpression : : get_output_type ( )
{
return output_type ;
}
2018-07-16 00:36:04 +02:00
2021-05-20 16:25:01 +02:00
pt : : TextStream * BaseExpression : : get_text_stream ( )
2021-05-12 00:27:35 +02:00
{
return out_stream ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : set_text_stream ( pt : : TextStream * out_stream )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = out_stream ;
}
2021-05-20 16:25:01 +02:00
pt : : TextStream * BaseExpression : : get_current_stream ( )
2018-07-16 00:36:04 +02:00
{
return out_stream ;
}
2019-03-31 22:21:12 +02:00
void BaseExpression : : allow_to_use_prefix ( bool use_prefix )
{
this - > use_prefix = use_prefix ;
}
2019-05-21 19:24:12 +02:00
bool BaseExpression : : get_allow_to_use_prefix ( )
2018-05-02 01:22:32 +02:00
{
2019-05-21 19:24:12 +02:00
return use_prefix ;
2019-03-31 22:21:12 +02:00
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : generate_from_model ( pt : : TextStream & stream , Model & model )
2023-02-26 18:28:16 +01:00
{
FT field_type = FT : : default_type ;
generate_from_model ( stream , model , field_type ) ;
}
void BaseExpression : : generate_from_model ( pt : : TextStream & stream , Model & model , const FT & field_type )
2018-03-23 20:26:57 +01:00
{
this - > out_stream = & stream ;
2023-02-26 18:28:16 +01:00
generate_from_model ( model , field_type ) ;
2018-04-16 01:00:17 +02:00
this - > out_stream = nullptr ;
2018-03-23 20:26:57 +01:00
}
2023-02-26 18:28:16 +01:00
void BaseExpression : : generate_from_model ( Model & model , const FT & field_type )
2018-04-17 00:46:25 +02:00
{
if ( out_stream )
{
2023-02-26 18:28:16 +01:00
if ( should_field_model_be_generated_as_null ( model . get_has_primary_key_set ( ) , field_type ) )
{
put_null_value ( ) ;
}
else
{
before_generate_from_model ( ) ;
dump_additional_info ( model ) ;
model . fields ( ) ;
add_additional_columns ( model ) ;
after_generate_from_model ( ) ;
}
2018-04-17 00:46:25 +02:00
}
}
2018-07-16 00:36:04 +02:00
2019-09-13 20:17:02 +02:00
void BaseExpression : : dump_additional_info ( Model & model )
{
if ( model . model_env & & model . model_env - > dump_mode )
{
2021-03-10 16:20:11 +01:00
field ( L " model_save_mode " , model . save_mode , FT : : no_insertable | FT : : no_updatable | FT : : no_fetchable , model . model_env ) ;
field ( L " has_primary_key_set " , model . has_primary_key_set , FT : : no_insertable | FT : : no_updatable | FT : : no_fetchable , model . model_env ) ;
2019-09-13 20:17:02 +02:00
}
}
2022-07-11 17:48:13 +02:00
void BaseExpression : : add_additional_columns ( Model & model )
{
}
2018-03-23 20:26:57 +01:00
void BaseExpression : : before_generate_from_model ( )
{
is_first_field = true ;
}
void BaseExpression : : after_generate_from_model ( )
{
}
2021-05-12 04:53:23 +02:00
bool BaseExpression : : can_field_be_generated ( const FT & )
2018-03-23 20:26:57 +01:00
{
return true ;
}
2023-02-26 18:28:16 +01:00
bool BaseExpression : : can_field_model_be_generated ( bool has_model_primary_key , const FT & field_type )
{
return true ;
}
2023-04-12 17:20:29 +02:00
bool BaseExpression : : can_field_list_be_generated ( const FT & )
{
return true ;
}
2023-02-26 18:28:16 +01:00
bool BaseExpression : : should_field_model_be_generated_as_null ( bool has_model_primary_key , const FT & field_type )
{
return false ;
}
2018-03-23 20:26:57 +01:00
void BaseExpression : : field_before ( )
{
if ( ! is_first_field )
{
// put a separator between fields
}
}
void BaseExpression : : field_after ( )
{
is_first_field = false ;
}
2019-03-31 22:21:12 +02:00
2021-05-13 00:19:22 +02:00
void BaseExpression : : put_field_name_and_table_if_needed ( const wchar_t * field_name , const FT & field_type , ModelEnv * model_env )
2019-05-31 20:28:09 +02:00
{
2021-07-07 01:06:01 +02:00
if ( ! field_type . is_raw_field_name ( ) & & use_prefix & & model_env )
2021-04-12 18:53:55 +02:00
{
2021-05-13 19:32:31 +02:00
if ( ! is_empty_field ( model_env - > table2_name ) )
{
put_table_with_index_and_field ( model_env - > table2_name , model_env - > table2_index , field_name , field_type ) ;
}
else
{
put_table_with_index_and_field ( model_env - > table_name , model_env - > table_index , field_name , field_type ) ;
}
2021-04-12 18:53:55 +02:00
}
2021-02-24 01:15:17 +01:00
else
2021-04-12 18:53:55 +02:00
{
2021-05-13 00:19:22 +02:00
put_field_name ( field_name , field_type , model_env ) ;
2021-04-12 18:53:55 +02:00
}
2019-05-31 20:28:09 +02:00
}
2021-05-13 00:19:22 +02:00
void BaseExpression : : put_field_name ( const wchar_t * field_name , const FT & field_type , ModelEnv * model_env )
2021-02-24 01:15:17 +01:00
{
2021-05-13 00:19:22 +02:00
if ( field_type . is_raw_field_name ( ) )
2019-05-31 20:28:09 +02:00
{
2021-05-13 00:19:22 +02:00
( * out_stream ) < < field_name ;
2021-02-24 01:15:17 +01:00
}
else
{
2021-05-13 02:32:03 +02:00
before_field_name ( ) ;
2022-12-05 06:36:13 +01:00
esc ( field_name , * out_stream , FT : : default_type , nullptr ) ; /* do not use provided field_type here - it would use e.g. binary mode if it was set, similar don't use model_env */
2021-05-13 02:32:03 +02:00
after_field_name ( ) ;
2018-05-02 01:22:32 +02:00
}
2018-03-23 20:26:57 +01:00
}
2021-05-13 00:19:22 +02:00
2023-02-26 22:19:46 +01:00
void BaseExpression : : put_field_closing_name ( const wchar_t * field_name , const FT & field_type , ModelEnv * model_env )
{
put_field_name ( field_name , field_type , model_env ) ;
}
void BaseExpression : : put_value_list_opening_index ( size_t index , const FT & field_type )
{
}
void BaseExpression : : put_value_list_closing_index ( size_t index , const FT & field_type )
{
}
2021-06-01 19:34:34 +02:00
2021-05-12 04:53:23 +02:00
void BaseExpression : : save_foreign_key ( const wchar_t * field_name , const FT & field_type , ModelEnv * model_env )
2019-05-31 20:28:09 +02:00
{
2021-05-20 16:25:01 +02:00
pt : : TextStream str ;
pt : : TextStream * old_out_stream = out_stream ;
2019-05-31 20:28:09 +02:00
out_stream = & str ;
2021-04-12 18:53:55 +02:00
put_field_name ( field_name , field_type , model_env ) ;
2019-05-31 20:28:09 +02:00
out_stream = old_out_stream ;
if ( model_env & & model_env - > finder_helper )
{
model_env - > finder_helper - > foreign_keys . emplace_back ( ) ;
std : : string & key_str = model_env - > finder_helper - > foreign_keys . back ( ) ;
2021-06-20 17:49:54 +02:00
str . to_str ( key_str , false ) ;
2019-05-31 20:28:09 +02:00
}
}
2018-07-16 00:36:04 +02:00
2021-05-13 02:32:03 +02:00
void BaseExpression : : schema_table_separator ( )
{
}
void BaseExpression : : table_field_separator ( )
2018-03-23 20:26:57 +01:00
{
}
2023-07-15 03:08:02 +02:00
void BaseExpression : : alias_names_separator ( )
{
}
2021-05-13 02:32:03 +02:00
void BaseExpression : : before_schema_name ( )
2018-03-23 20:26:57 +01:00
{
}
2021-05-13 02:32:03 +02:00
void BaseExpression : : after_schema_name ( )
2021-02-24 01:15:17 +01:00
{
}
2021-05-13 02:32:03 +02:00
void BaseExpression : : before_table_name ( )
2021-02-24 01:15:17 +01:00
{
}
2021-05-13 02:32:03 +02:00
void BaseExpression : : after_table_name ( )
2021-02-24 01:15:17 +01:00
{
}
2021-05-13 02:32:03 +02:00
void BaseExpression : : before_field_name ( )
2021-02-24 01:15:17 +01:00
{
}
2021-05-13 02:32:03 +02:00
void BaseExpression : : after_field_name ( )
{
}
2021-02-24 01:15:17 +01:00
2023-07-15 03:08:02 +02:00
void BaseExpression : : before_alias_name ( )
{
}
void BaseExpression : : after_alias_name ( )
{
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( const std : : wstring & , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( const std : : string & , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( const std : : wstring & , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( const std : : string & , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( const wchar_t * , const FT & field_type , ModelEnv * model_env )
2018-03-30 21:34:45 +02:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2018-03-30 21:34:45 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( const wchar_t * , const FT & field_type , ModelEnv * model_env )
2018-03-30 21:34:45 +02:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2018-03-30 21:34:45 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( const char * , const FT & field_type , ModelEnv * model_env )
2018-03-30 21:34:45 +02:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2018-03-30 21:34:45 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( const char * , const FT & field_type , ModelEnv * model_env )
2018-03-30 21:34:45 +02:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2018-03-30 21:34:45 +02:00
}
2021-05-11 22:11:31 +02:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( wchar_t , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( wchar_t , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( char , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( char , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( const pt : : Date & , const FT & field_type , ModelEnv * model_env )
2018-04-17 00:46:25 +02:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2018-04-17 00:46:25 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( const pt : : Date & , const FT & field_type , ModelEnv * model_env )
2018-04-17 00:46:25 +02:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2018-04-17 00:46:25 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value ( const pt : : Space & , const FT & field_type , ModelEnv * model_env )
2021-03-11 18:40:32 +01:00
{
2022-12-05 06:36:13 +01:00
before_field_value_string ( field_type , model_env ) ;
2021-03-11 18:40:32 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value ( const pt : : Space & , const FT & field_type , ModelEnv * model_env )
2021-03-11 18:40:32 +01:00
{
2022-12-05 06:36:13 +01:00
after_field_value_string ( field_type , model_env ) ;
2021-03-11 18:40:32 +01:00
}
2018-03-30 21:34:45 +02:00
2018-03-23 20:26:57 +01:00
void BaseExpression : : put_name_value_separator ( )
{
( * out_stream ) < < ' , ' ;
}
2021-05-11 22:11:31 +02:00
char BaseExpression : : char_to_hex_part ( char c )
2018-03-23 20:26:57 +01:00
{
2021-05-11 22:11:31 +02:00
if ( c < 10 )
return c + ' 0 ' ;
return c - 10 + ' A ' ;
2018-03-23 20:26:57 +01:00
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : char_to_hex ( char c , pt : : TextStream & stream )
2018-03-23 20:26:57 +01:00
{
2021-05-11 22:11:31 +02:00
stream < < char_to_hex_part ( ( ( unsigned char ) c ) > > 4 ) ;
stream < < char_to_hex_part ( ( ( unsigned char ) c ) & 0x0f ) ;
2018-03-23 20:26:57 +01:00
}
2022-02-08 12:47:34 +01:00
void BaseExpression : : char_to_hex ( wchar_t c , pt : : TextStream & stream )
{
unsigned int z = static_cast < unsigned int > ( c ) ;
char_to_hex ( ( char ) ( unsigned char ) ( z > > 24 ) , stream ) ;
char_to_hex ( ( char ) ( unsigned char ) ( z > > 16 ) , stream ) ;
char_to_hex ( ( char ) ( unsigned char ) ( z > > 8 ) , stream ) ;
char_to_hex ( ( char ) ( unsigned char ) ( z ) , stream ) ;
}
/*
* return true if the val character was escaped and put ( or ignored ) to the stream
*
*/
2022-12-05 06:36:13 +01:00
bool BaseExpression : : esc_char ( char val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2022-02-08 12:47:34 +01:00
{
2022-12-05 06:36:13 +01:00
return esc_char ( ( wchar_t ) ( unsigned char ) val , stream , field_type , model_env ) ;
2022-02-08 12:47:34 +01:00
}
/*
* return true if the val character was escaped and put ( or ignored ) to the stream
*
* in most caces you have to provide your own esc_char ( wchar_t val , pt : : TextStream & stream ) method
*
*/
2022-12-05 06:36:13 +01:00
bool BaseExpression : : esc_char ( wchar_t val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2022-02-08 12:47:34 +01:00
{
return false ;
}
2021-02-24 01:15:17 +01:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( char val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
if ( field_type . is_binary ( ) | | field_type . is_hexadecimal ( ) )
{
char_to_hex ( val , stream ) ;
}
else
2021-02-24 01:15:17 +01:00
{
2022-12-05 06:36:13 +01:00
if ( ! esc_char ( val , stream , field_type , model_env ) )
2022-02-08 12:47:34 +01:00
{
stream < < val ;
}
2021-02-24 01:15:17 +01:00
}
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( unsigned char val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
esc ( static_cast < char > ( val ) , stream , field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2018-03-23 20:26:57 +01:00
2021-05-11 22:11:31 +02:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( wchar_t val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-02-08 12:47:34 +01:00
if ( field_type . is_binary ( ) | | field_type . is_hexadecimal ( ) )
2018-03-23 20:26:57 +01:00
{
2022-02-08 12:47:34 +01:00
char_to_hex ( val , stream ) ;
2018-03-23 20:26:57 +01:00
}
2021-05-11 22:11:31 +02:00
else
{
2022-02-08 12:47:34 +01:00
if ( field_type . use_utf8 ( ) )
{
2022-12-05 06:36:13 +01:00
if ( ! esc_char ( val , stream , field_type , model_env ) )
2022-02-08 12:47:34 +01:00
{
stream < < val ;
}
}
else
{
char val_char = ( char ) ( unsigned char ) val ;
2022-12-05 06:36:13 +01:00
if ( ! esc_char ( val_char , stream , field_type , model_env ) )
2022-02-08 12:47:34 +01:00
{
stream < < val_char ;
}
}
2021-05-11 22:11:31 +02:00
}
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const wchar_t * val , bool has_known_length , size_t len , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-05-16 13:42:51 +02:00
if ( field_type . is_numeric ( ) )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
esc_numeric_string ( val , has_known_length , len , stream , field_type , model_env ) ;
2022-05-16 13:42:51 +02:00
}
else
{
2022-12-05 06:36:13 +01:00
esc_normal_string ( val , has_known_length , len , stream , field_type , model_env ) ;
2022-02-08 12:47:34 +01:00
}
}
2018-03-23 20:26:57 +01:00
2021-05-11 22:11:31 +02:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const char * val , bool has_known_length , size_t len , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2022-02-08 12:47:34 +01:00
{
2022-05-16 13:42:51 +02:00
if ( field_type . is_numeric ( ) )
{
2022-12-05 06:36:13 +01:00
esc_numeric_string ( val , has_known_length , len , stream , field_type , model_env ) ;
2022-05-16 13:42:51 +02:00
}
else
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
esc_normal_string ( val , has_known_length , len , stream , field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const std : : wstring & val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
esc ( val . c_str ( ) , true , val . size ( ) , stream , field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const wchar_t * val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2021-05-11 22:11:31 +02:00
{
2022-12-05 06:36:13 +01:00
esc ( val , false , 0 , stream , field_type , model_env ) ;
2021-05-11 22:11:31 +02:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const std : : string & val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
esc ( val . c_str ( ) , true , val . size ( ) , stream , field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const char * val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2022-12-05 06:36:13 +01:00
esc ( val , false , 0 , stream , field_type , model_env ) ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( bool val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
2018-04-12 18:05:14 +02:00
if ( val )
stream < < " true " ;
else
stream < < " false " ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( short val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( unsigned short val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( int val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( unsigned int val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( long val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( unsigned long val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( long long val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()
added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements
added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
2021-06-16 14:01:07 +02:00
stream < < val ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( unsigned long long val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()
added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements
added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
2021-06-16 14:01:07 +02:00
stream < < val ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( float val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( double val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
stream < < val ;
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( long double val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-03-23 20:26:57 +01:00
{
changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()
added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements
added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
2021-06-16 14:01:07 +02:00
stream < < val ;
2018-03-23 20:26:57 +01:00
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const pt : : Date & date , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-04-12 18:05:14 +02:00
{
2022-10-22 16:29:40 +02:00
if ( field_type . is_date_only ( ) )
{
date . SerializeYearMonthDay ( stream , false ) ;
}
else
if ( field_type . is_time_only ( ) )
{
date . SerializeHourMinSec ( stream ) ;
}
else
{
if ( field_type . is_no_time_zone ( ) )
{
date . Serialize ( stream ) ;
}
else
{
date . SerializeISO ( stream ) ;
}
}
2018-04-12 18:05:14 +02:00
}
changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()
added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements
added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
2021-06-16 14:01:07 +02:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const pt : : TextStream & val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2019-05-21 19:24:12 +02:00
{
2021-05-20 16:25:01 +02:00
pt : : TextStream : : const_iterator i = val . begin ( ) ;
2019-05-21 19:24:12 +02:00
for ( ; i ! = val . end ( ) ; + + i )
{
2022-12-05 06:36:13 +01:00
esc ( * i , stream , field_type , model_env ) ;
2019-05-21 19:24:12 +02:00
}
}
changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()
added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements
added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
2021-06-16 14:01:07 +02:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const pt : : WTextStream & val , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2021-03-11 12:22:37 +01:00
{
2021-05-20 16:25:01 +02:00
pt : : WTextStream : : const_iterator i = val . begin ( ) ;
2021-03-11 12:22:37 +01:00
for ( ; i ! = val . end ( ) ; + + i )
{
2022-12-05 06:36:13 +01:00
esc ( * i , stream , field_type , model_env ) ;
2021-03-11 12:22:37 +01:00
}
}
2018-03-23 20:26:57 +01:00
changed the way how we get a specific field value - now we do not use expressions (BaseExpression), to get the raw value we don't need an expression object:
- removed MORM_WORK_MODE_GET_SPECIFIC_FIELD_VALUE from expression work mode
- removed: void BaseExpression::field(const wchar_t * field_name, void (Model::*getter_method)(pt::TextStream &), const FT & field_type, ModelEnv * model_env)
- removed from BaseExpression: template<typename FunInfoStreamType> void field(const wchar_t * field_name, void (Model::*fun)(Ezc::FunInfo<FunInfoStreamType> &), const FT & field_type, ModelEnv * model_env)
- removed: void FlatConnector::to_text(const wchar_t * flat_field_name, pt::TextStream & stream, Model & model)
- renamed/changed: Model::put_field_value(...) -> Model::get_raw_value()
added classes:
class ModelWrapper - base wrapper class for a model or a model container
class ModelWrapperModel : public ModelWrapper - wrapper for a model
template<typename VectorType> class ModelWrapperVector : public ModelWrapper - wrapper for vector of models
template<typename ListType> class ModelWrapperList : public ModelWrapper - wrapper for list of models
ModelWrapper... classes are used by ezc library for iterating through child models and for iterating in [for...] statements
added to Model:
Model * get_model(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
ModelWrapper * get_model_wrapper(const wchar_t * db_field_name, const wchar_t * flat_field_name, bool put_log_if_not_found = true);
2021-06-16 14:01:07 +02:00
2022-12-05 06:36:13 +01:00
void BaseExpression : : esc ( const pt : : Space & space , pt : : TextStream & stream , const FT & field_type , ModelEnv * model_env )
2018-07-16 00:36:04 +02:00
{
2021-05-20 16:25:01 +02:00
pt : : WTextStream tmp_stream ;
2021-08-12 21:56:32 +02:00
bool pretty_print = field_type . is_pretty_print ( ) ;
if ( field_type . is_space ( ) )
space . serialize_to_space_stream ( tmp_stream , pretty_print ) ;
else
space . serialize_to_json_stream ( tmp_stream , pretty_print ) ;
2018-07-16 00:36:04 +02:00
2022-12-05 06:36:13 +01:00
esc ( tmp_stream , stream , field_type , model_env ) ;
2018-07-16 00:36:04 +02:00
}
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(char val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "char";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(unsigned char val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "unsigned char";
//}
//
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(const std::wstring & val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "text";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(const wchar_t * val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "text";
//}
//
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(const std::string & val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "text";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(const char * val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "text";
//}
//
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(bool val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "boolean";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(short val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "short integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(unsigned short val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "unsigned short integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(int val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(unsigned int val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "unsigned integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(long val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "long integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(unsigned long val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "unsigned long integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(long long val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "very long integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(unsigned long long val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "unsigned very long integer";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(float val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "float";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(double val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "double";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(long double val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "long double";
//}
//
2021-05-20 16:25:01 +02:00
////void BaseExpression::put_type(void* val, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
////{
////}
//
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(const pt::Date & date, pt::TextStream & stream)
2018-07-16 00:36:04 +02:00
//{
2021-03-11 18:40:32 +01:00
// stream << "date";
//}
//
2021-05-20 16:25:01 +02:00
//void BaseExpression::put_type(const Model & model, pt::TextStream & stream)
2021-03-11 18:40:32 +01:00
//{
// stream << "object";
2018-07-16 00:36:04 +02:00
//}
2022-12-05 06:36:13 +01:00
void BaseExpression : : before_field_value_string ( const FT & field_type , ModelEnv * model_env )
2018-07-16 00:36:04 +02:00
{
}
2022-12-05 06:36:13 +01:00
void BaseExpression : : after_field_value_string ( const FT & field_type , ModelEnv * model_env )
2018-07-16 00:36:04 +02:00
{
}
2018-03-23 20:26:57 +01:00
2021-05-13 02:32:03 +02:00
/*
* schema_name can be a null pointer or just pointing to an empty string
* in such a case we do not put the schema name
*/
2021-05-12 00:27:35 +02:00
void BaseExpression : : put_schema_table ( const wchar_t * schema_name , const wchar_t * table_name )
{
if ( out_stream )
{
2021-05-13 02:32:03 +02:00
bool has_schema = false ;
2021-05-12 00:27:35 +02:00
2021-05-13 02:32:03 +02:00
if ( ! is_empty_field ( schema_name ) )
{
has_schema = true ;
before_schema_name ( ) ;
esc ( schema_name , * out_stream ) ;
after_schema_name ( ) ;
}
2021-05-12 00:27:35 +02:00
2021-05-13 02:32:03 +02:00
if ( ! is_empty_field ( table_name ) )
{
if ( has_schema )
schema_table_separator ( ) ;
before_table_name ( ) ;
esc ( table_name , * out_stream ) ;
after_table_name ( ) ;
}
2021-05-12 00:27:35 +02:00
}
}
2021-05-13 02:32:03 +02:00
/*
* schema_name can be empty - in such a case we do not put the schema name
*/
2021-05-20 16:25:01 +02:00
void BaseExpression : : put_schema_table ( const pt : : WTextStream & schema_name , const pt : : WTextStream & table_name )
2021-05-12 00:27:35 +02:00
{
if ( out_stream )
{
2021-05-13 02:32:03 +02:00
bool has_schema = false ;
2021-05-12 00:27:35 +02:00
2021-05-13 02:32:03 +02:00
if ( ! schema_name . empty ( ) )
{
has_schema = true ;
before_schema_name ( ) ;
esc ( schema_name , * out_stream ) ;
after_schema_name ( ) ;
}
2021-05-12 00:27:35 +02:00
2021-05-13 02:32:03 +02:00
if ( ! table_name . empty ( ) )
{
if ( has_schema )
schema_table_separator ( ) ;
before_table_name ( ) ;
esc ( table_name , * out_stream ) ;
after_table_name ( ) ;
}
2021-05-12 00:27:35 +02:00
}
}
void BaseExpression : : put_table ( const wchar_t * table_name )
{
if ( out_stream )
{
2021-05-13 02:32:03 +02:00
before_table_name ( ) ;
2021-05-12 00:27:35 +02:00
esc ( table_name , * out_stream ) ;
2021-05-13 02:32:03 +02:00
after_table_name ( ) ;
2021-05-12 00:27:35 +02:00
}
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : put_table ( const pt : : WTextStream & table_name )
2021-05-12 00:27:35 +02:00
{
if ( out_stream )
{
2021-05-13 02:32:03 +02:00
before_table_name ( ) ;
2021-05-12 00:27:35 +02:00
esc ( table_name , * out_stream ) ;
2021-05-13 02:32:03 +02:00
after_table_name ( ) ;
2021-05-12 00:27:35 +02:00
}
}
void BaseExpression : : put_table_with_index ( const wchar_t * table_name , int index )
{
if ( out_stream )
{
2021-05-13 02:32:03 +02:00
before_table_name ( ) ;
2021-05-12 00:27:35 +02:00
esc ( table_name , * out_stream ) ;
if ( index > 1 )
{
( * out_stream ) < < index ;
}
2021-05-13 02:32:03 +02:00
after_table_name ( ) ;
2021-05-12 00:27:35 +02:00
}
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : put_table_with_index ( const pt : : WTextStream & table_name , int index )
2021-05-12 00:27:35 +02:00
{
if ( out_stream )
{
2021-05-13 02:32:03 +02:00
before_table_name ( ) ;
2021-05-12 00:27:35 +02:00
esc ( table_name , * out_stream ) ;
if ( index > 1 )
{
( * out_stream ) < < index ;
}
2021-05-13 02:32:03 +02:00
after_table_name ( ) ;
2021-05-12 00:27:35 +02:00
}
}
void BaseExpression : : put_table_with_index_and_field ( const wchar_t * table_name , int index , const wchar_t * field_name , const FT & field_type )
{
if ( out_stream )
{
put_table_with_index ( table_name , index ) ;
2021-05-13 02:32:03 +02:00
table_field_separator ( ) ;
2021-05-12 00:27:35 +02:00
put_field_name ( field_name , field_type , nullptr ) ;
}
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : put_table_with_index_and_field ( const pt : : WTextStream & table_name , int index , const wchar_t * field_name , const FT & field_type )
2021-05-12 00:27:35 +02:00
{
if ( out_stream )
{
put_table_with_index ( table_name , index ) ;
2021-05-13 02:32:03 +02:00
table_field_separator ( ) ;
2021-05-12 00:27:35 +02:00
put_field_name ( field_name , field_type , nullptr ) ;
}
}
2021-05-13 00:19:22 +02:00
void BaseExpression : : put_table_and_field ( const wchar_t * table_name , const wchar_t * field_name , const FT & field_type )
{
if ( out_stream )
{
put_table ( table_name ) ;
2021-05-13 02:32:03 +02:00
table_field_separator ( ) ;
2021-05-13 00:19:22 +02:00
put_field_name ( field_name , field_type , nullptr ) ;
}
}
2023-07-15 03:08:02 +02:00
2021-05-20 16:25:01 +02:00
void BaseExpression : : put_table_and_field ( const pt : : WTextStream & table_name , const wchar_t * field_name , const FT & field_type )
2021-05-13 00:19:22 +02:00
{
if ( out_stream )
{
put_table ( table_name ) ;
2021-05-13 02:32:03 +02:00
table_field_separator ( ) ;
2021-05-13 00:19:22 +02:00
put_field_name ( field_name , field_type , nullptr ) ;
}
}
2021-05-12 00:27:35 +02:00
2023-07-15 03:08:02 +02:00
void BaseExpression : : put_alias ( const pt : : WTextStream & alias_name , int index )
{
if ( out_stream )
{
before_alias_name ( ) ;
esc ( alias_name , * out_stream ) ;
if ( index > 1 )
{
( * out_stream ) < < index ;
}
after_alias_name ( ) ;
}
}
void BaseExpression : : put_alias ( const pt : : WTextStream & alias_name_prefix , int index , const wchar_t * alias_name_postfix )
{
if ( out_stream )
{
before_alias_name ( ) ;
esc ( alias_name_prefix , * out_stream ) ;
if ( index > 1 )
{
( * out_stream ) < < index ;
}
alias_names_separator ( ) ;
esc ( alias_name_postfix , * out_stream ) ;
after_alias_name ( ) ;
}
}
2021-05-12 00:27:35 +02:00
2023-10-10 19:43:02 +02:00
void BaseExpression : : put_string ( const char * str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
2023-10-10 19:43:02 +02:00
put_string_generic ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : put_string ( const wchar_t * str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
2023-10-10 19:43:02 +02:00
put_string_generic ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : put_string ( const std : : string & str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
2023-10-10 19:43:02 +02:00
put_string_generic ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : put_string ( const std : : wstring & str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
2023-10-10 19:43:02 +02:00
put_string_generic ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : put_stream ( const pt : : TextStream & str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 13:26:30 +01:00
{
2023-10-10 19:43:02 +02:00
put_string_generic ( str , field_type , add_quotes , model_env ) ;
2022-12-02 13:26:30 +01:00
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : put_stream ( const pt : : WTextStream & str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 13:26:30 +01:00
{
2023-10-10 19:43:02 +02:00
put_string_generic ( str , field_type , add_quotes , model_env ) ;
2022-12-02 13:26:30 +01:00
}
2022-12-02 11:45:19 +01:00
2021-05-20 16:25:01 +02:00
void BaseExpression : : schema_table_to_stream ( pt : : TextStream & stream , const wchar_t * schema_name , const wchar_t * table_name )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_schema_table ( schema_name , table_name ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : schema_table_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & schema_name , const pt : : WTextStream & table_name )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_schema_table ( schema_name , table_name ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_to_stream ( pt : : TextStream & stream , const wchar_t * table_name )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_table ( table_name ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & table_name )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_table ( table_name ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_with_index_to_stream ( pt : : TextStream & stream , const wchar_t * table_name , int index )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_table_with_index ( table_name , index ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_with_index_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & table_name , int index )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_table_with_index ( table_name , index ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_with_index_and_field_to_stream ( pt : : TextStream & stream , const wchar_t * table_name , int index , const wchar_t * field_name , const FT & field_type )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_table_with_index_and_field ( table_name , index , field_name , field_type ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_with_index_and_field_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & table_name , int index , const wchar_t * field_name , const FT & field_type )
2021-05-12 00:27:35 +02:00
{
this - > out_stream = & stream ;
put_table_with_index_and_field ( table_name , index , field_name , field_type ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_and_field_to_stream ( pt : : TextStream & stream , const wchar_t * table_name , const wchar_t * field_name , const FT & field_type )
2021-05-13 00:19:22 +02:00
{
this - > out_stream = & stream ;
put_table_and_field ( table_name , field_name , field_type ) ;
this - > out_stream = nullptr ;
}
2021-05-20 16:25:01 +02:00
void BaseExpression : : table_and_field_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & table_name , const wchar_t * field_name , const FT & field_type )
2021-05-13 00:19:22 +02:00
{
this - > out_stream = & stream ;
put_table_and_field ( table_name , field_name , field_type ) ;
this - > out_stream = nullptr ;
}
2023-07-15 03:08:02 +02:00
void BaseExpression : : alias_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & alias_name , int index )
{
this - > out_stream = & stream ;
put_alias ( alias_name , index ) ;
this - > out_stream = nullptr ;
}
void BaseExpression : : alias_to_stream ( pt : : TextStream & stream , const pt : : WTextStream & alias_name_prefix , int index , const wchar_t * alias_name_postfix )
{
this - > out_stream = & stream ;
put_alias ( alias_name_prefix , index , alias_name_postfix ) ;
this - > out_stream = nullptr ;
}
2021-03-11 18:40:32 +01:00
2023-10-10 19:43:02 +02:00
void BaseExpression : : string_to_stream ( pt : : TextStream & stream , const char * str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
this - > out_stream = & stream ;
2023-10-10 19:43:02 +02:00
put_string ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
this - > out_stream = nullptr ;
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : string_to_stream ( pt : : TextStream & stream , const wchar_t * str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
this - > out_stream = & stream ;
2023-10-10 19:43:02 +02:00
put_string ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
this - > out_stream = nullptr ;
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : string_to_stream ( pt : : TextStream & stream , const std : : string & str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
this - > out_stream = & stream ;
2023-10-10 19:43:02 +02:00
put_string ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
this - > out_stream = nullptr ;
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : string_to_stream ( pt : : TextStream & stream , const std : : wstring & str , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 11:45:19 +01:00
{
this - > out_stream = & stream ;
2023-10-10 19:43:02 +02:00
put_string ( str , field_type , add_quotes , model_env ) ;
2022-12-02 11:45:19 +01:00
this - > out_stream = nullptr ;
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : stream_to_stream ( pt : : TextStream & stream_out , const pt : : TextStream & stream_in , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 13:26:30 +01:00
{
this - > out_stream = & stream_out ;
2023-10-10 19:43:02 +02:00
put_stream ( stream_in , field_type , add_quotes , model_env ) ;
2022-12-02 13:26:30 +01:00
this - > out_stream = nullptr ;
}
2023-10-10 19:43:02 +02:00
void BaseExpression : : stream_to_stream ( pt : : TextStream & stream_out , const pt : : WTextStream & stream_in , const FT & field_type , bool add_quotes , ModelEnv * model_env )
2022-12-02 13:26:30 +01:00
{
this - > out_stream = & stream_out ;
2023-10-10 19:43:02 +02:00
put_stream ( stream_in , field_type , add_quotes , model_env ) ;
2022-12-02 13:26:30 +01:00
this - > out_stream = nullptr ;
}
2022-12-02 11:45:19 +01:00
2021-05-13 02:32:03 +02:00
bool BaseExpression : : is_empty_field ( const wchar_t * value )
{
return ( ! value | | * value = = ' \0 ' ) ;
}
2018-03-23 20:26:57 +01:00
}