Successfully running the first prepared select statement including result evaluation

include/sqlpp11/any.h

@@ -52,6 +52,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T any;
+						T& operator()() { return any; }
+						const T& operator()() const { return any; }
 					};
 			};
 

include/sqlpp11/avg.h

@@ -51,6 +51,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T avg;
+						T& operator()() { return avg; }
+						const T& operator()() const { return avg; }
 					};
 			};
 

include/sqlpp11/count.h

@@ -51,6 +51,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T count;
+						T& operator()() { return count; }
+						const T& operator()() const { return count; }
 					};
 			};
 

include/sqlpp11/exists.h

@@ -51,6 +51,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T exists;
+						T& operator()() { return exists; }
+						const T& operator()() const { return exists; }
 					};
 			};
 

include/sqlpp11/floating_point.h

@@ -48,25 +48,31 @@ namespace sqlpp
 			using _is_expression = std::true_type;
 			using _cpp_value_type = double;
 			
-			template<bool TrivialValueIsNull>
 			struct _parameter_t
 			{
-				using _value_type = floating_point;
+				using _value_type = integral;
 
-				_parameter_t():
+				_parameter_t(const std::true_type&):
+					_trivial_value_is_null(true),
 					_value(0),
-					_is_null(TrivialValueIsNull and _is_trivial())
+					_is_null(_trivial_value_is_null	and _is_trivial())
+					{}
+
+				_parameter_t(const std::false_type&):
+					_trivial_value_is_null(false),
+					_value(0),
+					_is_null(_trivial_value_is_null	and _is_trivial())
 					{}
 
 				_parameter_t(const _cpp_value_type& value):
 					_value(value),
-					_is_null(TrivialValueIsNull and _is_trivial())
+					_is_null(_trivial_value_is_null and _is_trivial())
 					{}
 
 				_parameter_t& operator=(const _cpp_value_type& value)
 				{
 					_value = value;
-					_is_null = (TrivialValueIsNull and _is_trivial());
+					_is_null = (_trivial_value_is_null and _is_trivial());
 					return *this;
 				}
 
@@ -90,22 +96,28 @@ namespace sqlpp
 					return _is_null; 
 				}
 
-				_cpp_value_type value() const
+				const _cpp_value_type& value() const
 				{
 					return _value;
 				}
 
-				operator _cpp_value_type() const { return value(); }
+				operator _cpp_value_type() const { return _value; }
+
+				template<typename Target>
+					void bind(Target& target, size_t index) const
+					{
+						target.bind_floating_point_parameter(index, &_value, _is_null);
+					}
 
 			private:
+				bool _trivial_value_is_null;
 				_cpp_value_type _value;
 				bool _is_null;
 			};
 
-			template<size_t index>
 			struct _result_entry_t
 			{
-				using _value_type = floating_point;
+				using _value_type = integral;
 
 				_result_entry_t():
 					_is_valid(false),
@@ -113,18 +125,24 @@ namespace sqlpp
 					_value(0)
 					{}
 
-				_result_entry_t(const char_result_row_t& row):
-					_is_valid(row.data != nullptr),
-					_is_null(row.data == nullptr or row.data[index] == nullptr),
-					_value(_is_null ? 0 : std::strtod(row.data[index], nullptr))
+				_result_entry_t(const char* data, size_t):
+					_is_valid(true),
+					_is_null(data == nullptr),
+					_value(_is_null ? 0 : std::strtoll(data, nullptr, 10))
 					{}
 
-				_result_entry_t& operator=(const char_result_row_t& row)
+				void assign(const char* data, size_t)
 				{
-					_is_valid = (row.data != nullptr);
-					_is_null = row.data == nullptr or row.data[index] == nullptr;
-					_value = _is_null ? 0 : std::strtod(row.data[index], nullptr);
-					return *this;
+					_is_valid = true;
+					_is_null = data == nullptr;
+					_value = _is_null ? 0 : std::strtoll(data, nullptr, 10);
+				}
+
+				void invalidate()
+				{
+					_is_valid = false;
+					_is_null = true;
+					_value = 0;
 				}
 
 				template<typename Db>
@@ -151,6 +169,12 @@ namespace sqlpp
 
 				operator _cpp_value_type() const { return value(); }
 
+				template<typename Target>
+					void bind(Target& target, size_t i)
+					{
+						target.bind_floating_point_result(i, &_value, &_is_null);
+					}
+
 			private:
 				bool _is_valid;
 				bool _is_null;
@@ -243,8 +267,7 @@ namespace sqlpp
 			};
 		};
 
-		template<size_t index>
-		std::ostream& operator<<(std::ostream& os, const floating_point::_result_entry_t<index>& e)
+		inline std::ostream& operator<<(std::ostream& os, const floating_point::_result_entry_t& e)
 		{
 			return os << e.value();
 		}

include/sqlpp11/integral.h

@@ -63,13 +63,7 @@ namespace sqlpp
 					_is_null(_trivial_value_is_null	and _is_trivial())
 					{}
 
-				_parameter_t(bool trivial_value_is_null):
-					_trivial_value_is_null(trivial_value_is_null),
-					_value(0),
-					_is_null(_trivial_value_is_null	and _is_trivial())
-					{}
-
-				_parameter_t(const _cpp_value_type& value):
+				explicit _parameter_t(const _cpp_value_type& value):
 					_value(value),
 					_is_null(_trivial_value_is_null and _is_trivial())
 					{}
@@ -81,11 +75,10 @@ namespace sqlpp
 					return *this;
 				}
 
-				_parameter_t& operator=(const std::nullptr_t&)
+				void set_null()
 				{
 					_value = 0;
 					_is_null = true;
-					return *this;
 				}
 
 				template<typename Db>
@@ -150,6 +143,11 @@ namespace sqlpp
 					_value = 0;
 				}
 
+				void validate()
+				{
+					_is_valid = true;
+				}
+
 				template<typename Db>
 					void serialize(std::ostream& os, Db& db) const
 					{

include/sqlpp11/max.h

@@ -51,6 +51,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T max;
+						T& operator()() { return max; }
+						const T& operator()() const { return max; }
 					};
 			};
 

include/sqlpp11/min.h

@@ -51,6 +51,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T min;
+						T& operator()() { return min; }
+						const T& operator()() const { return min; }
 					};
 			};
 

include/sqlpp11/prepared_select.h

@@ -43,7 +43,7 @@ namespace sqlpp
 			auto run(Db& db) const
 				-> result_t<decltype(db.run_prepared_select(*this)), _result_row_t>
 			{
-				return {db.run_prepared_select(*this)};
+				return {db.run_prepared_select(*this), _dynamic_names};
 			}
 
 			void bind_params() const

include/sqlpp11/result.h

@@ -90,7 +90,7 @@ namespace sqlpp
 
 				void operator++()
 				{
-					_result.next(result_row);
+					_result.next(_result_row);
 				}
 
 				db_result_t& _result;

include/sqlpp11/result_row.h

@@ -65,6 +65,12 @@ namespace sqlpp
 					return *this;
 				}
 
+				void validate()
+				{
+					_field::operator()().validate();
+					_rest::validate();
+				}
+
 				void invalidate()
 				{
 					_field::operator()().invalidate();
@@ -97,14 +103,20 @@ namespace sqlpp
 
 				result_row_impl& operator=(const char_result_row_t& char_result_row_t)
 				{
-					_multi_field::operator=({char_result_row_t});
+					_multi_field::operator()() = char_result_row_t;
 					_rest::operator=(char_result_row_t);
 					return *this;
 				}
 
+				void validate()
+				{
+					_multi_field::operator()().validate();
+					_rest::validate();
+				}
+
 				void invalidate()
 				{
-					_multi_field::invalidate();
+					_multi_field::operator()().invalidate();
 					_rest::invalidate();
 				}
 
@@ -130,6 +142,10 @@ namespace sqlpp
 					return *this;
 				}
 
+				void validate()
+				{
+				}
+
 				void invalidate()
 				{
 				}
@@ -173,6 +189,12 @@ namespace sqlpp
 			return *this;
 		}
 
+		void validate()
+		{
+			_impl::validate();
+			_is_valid = true;
+		}
+
 		void invalidate()
 		{
 			_impl::invalidate();

include/sqlpp11/select.h

@@ -594,7 +594,7 @@ namespace sqlpp
 					// FIXME: Check for missing aliases (if references are used)
 					// FIXME: Check for missing tables, well, actually, check for missing tables at the where(), order_by(), etc.
 
-					return {db.select(*this)};
+					return {db.select(*this), get_dynamic_names()};
 				}
 
 			template<typename Db>

include/sqlpp11/some.h

@@ -52,6 +52,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T some;
+						T& operator()() { return some; }
+						const T& operator()() const { return some; }
 					};
 			};
 

include/sqlpp11/sum.h

@@ -51,6 +51,8 @@ namespace sqlpp
 					struct _member_t
 					{
 						T sum;
+						T& operator()() { return sum; }
+						const T& operator()() const { return sum; }
 					};
 			};