Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(292)
Issues Repositories
Recent Issues | Sign in with your Google Account to create issues and add comments

Delta Between Two Patch Sets: gears/database2/statement.cc

Issue 717: Database2Values, argument conversion implemented (Closed) SVN Base: http://google-gears.googlecode.com/svn/contrib/dimitri.glazkov/database2/
Left Patch Set: Variant, multiple-row capability added Created 4 months, 2 weeks ago
Right Patch Set: Created 4 months, 4 weeks ago
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
Left: Side by side diff | Download
Right: Side by side diff | Download
« gears/database2/connection.h ('k') | gears/database2/statement.h » ('j') | Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')
LEFTRIGHT
1 // Copyright 2008, Google Inc. 1 // Copyright 2008, Google Inc.
2 // 2 //
3 // Redistribution and use in source and binary forms, with or without 3 // Redistribution and use in source and binary forms, with or without
4 // modification, are permitted provided that the following conditions are met: 4 // modification, are permitted provided that the following conditions are met:
5 // 5 //
6 // 1. Redistributions of source code must retain the above copyright notice, 6 // 1. Redistributions of source code must retain the above copyright notice,
7 // this list of conditions and the following disclaimer. 7 // this list of conditions and the following disclaimer.
8 // 2. Redistributions in binary form must reproduce the above copyright notice, 8 // 2. Redistributions in binary form must reproduce the above copyright notice,
9 // this list of conditions and the following disclaimer in the documentation 9 // this list of conditions and the following disclaimer in the documentation
10 // and/or other materials provided with the distribution. 10 // and/or other materials provided with the distribution.
(...skipping 25 matching lines...) Show 10 above Show 10 below
36 if (HasCallback()) { 36 if (HasCallback()) {
37 tx->GetJsRunner()->InvokeCallback(callback_.get(), ARRAYSIZE(send_argv), 37 tx->GetJsRunner()->InvokeCallback(callback_.get(), ARRAYSIZE(send_argv),
38 send_argv, NULL); 38 send_argv, NULL);
39 } 39 }
40 } 40 }
41 41
42 void Database2Statement::InvokeErrorCallback(Database2Transaction *tx, 42 void Database2Statement::InvokeErrorCallback(Database2Transaction *tx,
43 JsObject *error) { 43 JsObject *error) {
44 } 44 }
45 45
46 bool Database2Statement::Create(const std::string16 &sql_statement, 46 bool Database2Statement::Create(const std::string16 &sql_statement,
47 JsArray *sql_arguments, 47 const JsArray &sql_arguments,
48 JsRootedCallback *callback, 48 JsRootedCallback *callback,
49 JsRootedCallback *error_callback, 49 JsRootedCallback *error_callback,
50 Database2Statement **instance) { 50 Database2Statement **instance) {
51 assert(instance && *instance); 51 scoped_ptr<Database2Statement> statement;
52 52 statement.reset(new Database2Statement());
53 scoped_ptr<Database2Statement> statement(new Database2Statement());
54
55 // NULL should be passed if no arguments are specified
56 assert(!sql_arguments || !JsTokenIsNullOrUndefined(sql_arguments->token()));
57 // NULL should be passed if a callback is not specified
58 assert(!callback || !JsTokenIsNullOrUndefined(callback->token()));
59 assert(!error_callback || !JsTokenIsNullOrUndefined(error_callback->token()));
60
61 statement->sql_statement_.assign(sql_statement); 53 statement->sql_statement_.assign(sql_statement);
62 statement->callback_.reset(callback); 54 statement->callback_.reset(callback);
63 statement->error_callback_.reset(error_callback); 55 statement->error_callback_.reset(error_callback);
64 56
65 Database2Values *arguments; 57 Database2Values *arguments;
66 if (!Database2Values::CreateFromJsArray(sql_arguments, &arguments)) { 58 if (!Database2Values::CreateFromJsArray(sql_arguments, &arguments)) {
67 return false; 59 return false;
68 } 60 }
69 61
70 statement->arguments_.reset(arguments); 62 statement->arguments_.reset(arguments);
71 63
72 *instance = statement.release(); 64 *instance = statement.release();
73 return true; 65 return true;
74 } 66 }
75 67
76 // static 68 // static
77 bool Database2Values::CreateFromJsArray(const JsArray *js_array, 69 bool Database2Values::CreateFromJsArray(const JsArray &sql_arguments,
78 Database2Values **instance) { 70 Database2Values **instance) {
79 assert(instance && *instance); 71 scoped_ptr<Database2Values> result;
72 result.reset(new Database2Values());
80 73
81 scoped_ptr<Database2Values> result(new Database2Values()); 74 // since the arguments are optional, their token may be NULL
82 75 if (sql_arguments.token() == NULL) {
Aaron 2008/05/11 18:11:21 It's not a good idea to compare token() to NULL. I
Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > We have a s
83 // since the arguments are optional, they could be passed as NULL 76 result->arguments_.reset(NULL);
84 if (js_array == NULL) {
85 result->length_ = 0; 77 result->length_ = 0;
86 *instance = result.release(); 78 *instance = result.release();
87 return true; 79 return true;
88 } 80 }
89 81
90 int len; 82 int len;
91 if (!js_array->GetLength(&len)) { 83 if (!sql_arguments.GetLength(&len)) {
92 // unable to query JsArray, someting's gone horribly wrong 84 // unable to query JsArray, someting's gone horribly wrong
93 // returning with failure will trigger an internal error 85 // returning with failure will trigger an internal error
Aaron 2008/05/11 18:11:21 Silent failures look weird to me. Maybe assert(fal
Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > Silent fail
94 assert(false);
95 return false; 86 return false;
96 } 87 }
97 88
98 result->length_ = len; 89 result->length_ = len;
99 // a JsArray produces one row of values 90
100 result->StartNewRow(); 91 result->arguments_.reset(new JsParamToSend[len]);
101 Variant *row = result->rows_.back();
102 for(int i = 0; i < len; i++) { 92 for(int i = 0; i < len; i++) {
103 switch(js_array->GetElementType(i)) { 93 if (!SetJsParamToSend(sql_arguments, i, result->arguments_.get())) {
104 case JSPARAM_INT: { 94 // one invalid argument make the whole statement bogus
105 int value; 95 // no need to process any more parameters
106 if (!js_array->GetElementAsInt(i, &value)) { 96 // set length to only include last processed parameter
107 return false; 97 result->length_ = i;
108 } 98 return false;
109 row[i].type = JSPARAM_INT;
110 row[i].int_value = value;
111 break;
112 }
113 case JSPARAM_DOUBLE: {
114 double value;
115 if (!js_array->GetElementAsDouble(i, &value)) {
116 return false;
117 }
118 row[i].type = JSPARAM_DOUBLE;
119 row[i].double_value = value;
120 break;
121 }
122 case JSPARAM_STRING16: {
123 std::string16 value;
124 if (!js_array->GetElementAsString(i, &value)) {
125 return false;
126 }
127 row[i].type = JSPARAM_STRING16;
128 row[i].string_value = new std::string16(value);
129 break;
130 }
131 case JSPARAM_NULL: {
132 // Variant's type is set to JSPARAM_NULL by default, no need to do
133 // anything here
134 break;
135 }
136 default: {
137 // invalid type
138 return false;
139 }
140 } 99 }
141 } 100 }
142 101
143 *instance = result.release(); 102 *instance = result.release();
144 return true; 103 return true;
145 } 104 }
146 105
147 void Database2Values::StartNewRow() { 106 // static
148 rows_.push_back(new Variant[length_]); 107 bool Database2Values::SetJsParamToSend(JsArray js_array,
149 } 108 int index,
150 109 JsParamToSend *arguments) {
151 bool Database2Values::Next() { 110 assert(index >= 0 && arguments);
152 return ++current_row_ >= length_; 111 JsParamToSend *param = arguments + index;
Aaron 2008/05/11 18:11:21 Does arguments[index] work? I think it's easier to
Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > Does argume
112 param->type = js_array.GetElementType(index);
113 switch(param->type) {
114 case JSPARAM_INT: {
115 scoped_ptr<int> value;
116 value.reset(new int);
Aaron 2008/05/11 18:11:21 The heap allocated integers are unfortuante :-/. I
Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > The heap al
117 if (js_array.GetElementAsInt(index, value.get())) {
118 param->value_ptr = value.release();
119 return true;
120 }
121 return false;
122 }
123 case JSPARAM_DOUBLE: {
124 scoped_ptr<double> value;
125 value.reset(new double);
126 if (js_array.GetElementAsDouble(index, value.get())) {
127 param->value_ptr = value.release();
128 return true;
129 }
130 return false;
131 }
132 case JSPARAM_STRING16: {
133 scoped_ptr<std::string16> value;
134 value.reset(new std::string16());
135 if (js_array.GetElementAsString(index, value.get())) {
136 param->value_ptr = value.release();
137 return true;
138 }
139 return false;
140 }
141 case JSPARAM_NULL: {
142 param->value_ptr = NULL;
143 return true;
144 }
145 }
146 // all other types are considered invalid
147 return false;
153 } 148 }
154 149
155 JsParamType Database2Values::GetType(int index) const { 150 JsParamType Database2Values::GetType(int index) const {
156 return current(index).type; 151 assert(index >= 0 && index < length_);
152 return arguments_[index].type;
157 } 153 }
158 154
159 bool Database2Values::GetElementAsInt(int index, int *value) { 155 int Database2Values::GetAsInt(int index) const {
160 assert(current(index).type == JSPARAM_INT); 156 assert(index >= 0 && index < length_);
161 assert(value); 157 JsParamToSend param = arguments_[index];
162 *value = current(index).int_value; 158 assert(param.type == JSPARAM_INT);
163 return true; 159 return *static_cast<int*>(const_cast<void*>(param.value_ptr));
164 } 160 }
165 161
166 bool Database2Values::GetElementAsDouble(int index, double *value) { 162 double Database2Values::GetAsDouble(int index) const {
167 assert(current(index).type = JSPARAM_DOUBLE); 163 assert(index >= 0 && index < length_);
168 assert(value); 164 JsParamToSend param = arguments_[index];
169 *value = current(index).double_value; 165 assert(param.type == JSPARAM_DOUBLE);
170 return true; 166 return *static_cast<int*>(const_cast<void*>(param.value_ptr));
171 } 167 }
172 168
173 bool Database2Values::GetElementAsString(int index, std::string16 *value) { 169 std::string16 &Database2Values::GetAsString(int index) const {
174 assert(current(index).type = JSPARAM_STRING16); 170 assert(index >= 0 && index < length_);
175 assert(value); 171 JsParamToSend param = arguments_[index];
176 *value = *(current(index).string_value); 172 assert(param.type == JSPARAM_STRING16);
177 return true; 173 return *static_cast<std::string16*>(const_cast<void*>(param.value_ptr));
178 } 174 }
175
176 Database2Values::~Database2Values() {
177 // dispose of the data, pointed to the value_ptrs
178 for(int i = 0; i < length_; i++) {
179 JsParamToSend param = arguments_[i];
180 if (param.value_ptr) delete param.value_ptr;
181 }
182 }
LEFTRIGHT
« gears/database2/connection.h ('k') | gears/database2/statement.h » ('j') | Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Toggle Comments ('s')

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld r338