Annotation of parser3/src/classes/void.C, revision 1.42

1.1       parser      1: /** @file
                      2:        Parser: @b VOID parser class.
                      3: 
1.42    ! misha       4:        Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
1.16      paf         5:        Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.20      paf         6: */
1.1       parser      7: 
1.42    ! misha       8: static const char * const IDENT_VOID_C="$Date: 2008-09-04 13:15:36 $";
1.1       parser      9: 
                     10: #include "classes.h"
1.29      paf        11: #include "pa_vmethod_frame.h"
                     12: 
1.1       parser     13: #include "pa_request.h"
                     14: #include "pa_vint.h"
                     15: #include "pa_vdouble.h"
                     16: #include "pa_vvoid.h"
1.37      misha      17: #include "pa_vbool.h"
1.1       parser     18: #include "pa_sql_connection.h"
                     19: 
1.33      paf        20: // externs
                     21: 
                     22: extern String sql_bind_name;
                     23: 
1.1       parser     24: // class
                     25: 
1.29      paf        26: class MVoid: public Methoded {
1.1       parser     27: public:
1.29      paf        28:        MVoid();
1.1       parser     29: public: // Methoded
                     30:        bool used_directly() { return true; }
                     31: };
                     32: 
1.29      paf        33: // global variable
                     34: 
                     35: DECLARE_CLASS_VAR(void, new MVoid, 0);
                     36: 
1.1       parser     37: // methods
                     38: 
1.29      paf        39: static void _length(Request& r, MethodParams&) {
1.24      paf        40:        // always zero
1.29      paf        41:        r.write_no_lang(*new VInt(0));
1.23      paf        42: }
                     43: 
1.29      paf        44: static void _pos(Request& r, MethodParams& params) {
                     45:        // just checking for consistency
                     46:        params.as_no_junction(0, "substr must not be code");
1.40      misha      47:        if(params.count()>1){
                     48:                ssize_t offset=params.as_int(1, "n must be int", r);
                     49:                if(offset<0)
                     50:                        throw Exception(PARSER_RUNTIME,
                     51:                                0, 
                     52:                                "n(%d) must be >=0", offset);
                     53:        }
1.24      paf        54:        // never found
1.29      paf        55:        r.write_no_lang(*new VInt(-1));
1.24      paf        56: }
                     57: 
1.29      paf        58: static void _int(Request& r, MethodParams& params) {
                     59:        VVoid& vvoid=GET_SELF(r, VVoid);
                     60:        r.write_no_lang(*new VInt(
                     61:                params.count()==0?vvoid.as_int():params.as_int(0, "default must be int", r)));
1.1       parser     62: }
                     63: 
1.29      paf        64: static void _double(Request& r, MethodParams& params) {
                     65:        VVoid& vvoid=GET_SELF(r, VVoid);
                     66:        r.write_no_lang(*new VDouble(
                     67:                params.count()==0?vvoid.as_double():params.as_double(0, "default must be double", r)));
1.1       parser     68: }
                     69: 
1.37      misha      70: static void _bool(Request& r, MethodParams& params) {
                     71:        VVoid& vvoid=GET_SELF(r, VVoid);
1.42    ! misha      72:        r.write_no_lang(VBool::get(params.count()==0?vvoid.as_bool():params.as_bool(0, "default must be bool", r)));
1.37      misha      73: }
                     74: 
1.5       parser     75: #ifndef DOXYGEN
1.26      paf        76: class Void_sql_event_handlers: public SQL_Driver_query_event_handlers {
1.29      paf        77:        const String& statement_string;
1.5       parser     78: public:
1.29      paf        79:        Void_sql_event_handlers(const String& astatement_string): statement_string(astatement_string) {}
                     80:        bool add_column(SQL_Error& /*error*/, const char* /*str*/, size_t /*length*/) { /* ignore */ return false; }
1.27      paf        81:        bool before_rows(SQL_Error& error) {
1.5       parser     82:                // there are some result rows, which is wrong
1.38      misha      83:                error=SQL_Error(PARSER_RUNTIME,
1.29      paf        84:                        /*statement_string,*/
1.5       parser     85:                        "must return nothing");
1.27      paf        86:                return true;
1.5       parser     87:        }
1.27      paf        88:        bool add_row(SQL_Error& /*error*/) { /* never */ return false; }
1.29      paf        89:        bool add_row_cell(SQL_Error& /*error*/, const char* /*str*/, size_t /*length*/) { /* never */ return false; }
1.5       parser     90: 
                     91: };
                     92: #endif
1.34      paf        93: 
                     94: extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders);
                     95: extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders);
                     96: 
1.29      paf        97: static void _sql(Request& r, MethodParams& params) {
                     98:        Value& statement=params.as_junction(0, "statement must be code");
1.1       parser     99: 
1.33      paf       100:        HashStringValue* bind=0;
                    101:        if(params.count()>1) {
                    102:                Value& voptions=params.as_no_junction(1, "options must be hash, not code");
1.36      paf       103:                if(voptions.is_defined() && !voptions.is_string())
1.33      paf       104:                        if(HashStringValue* options=voptions.get_hash()) {
                    105:                                int valid_options=0;
                    106:                                if(Value* vbind=options->get(sql_bind_name)) {
                    107:                                        valid_options++;
                    108:                                        bind=vbind->get_hash();
                    109:                                }
                    110:                                if(valid_options!=options->count())
1.38      misha     111:                                        throw Exception(PARSER_RUNTIME,
1.33      paf       112:                                                0,
                    113:                                                "called with invalid option");
                    114:                        } else
1.38      misha     115:                                throw Exception(PARSER_RUNTIME,
1.33      paf       116:                                        0,
                    117:                                        "options must be hash");
                    118:        }
                    119: 
                    120:        SQL_Driver::Placeholder* placeholders=0;
                    121:        uint placeholders_count=0;
                    122:        if(bind)
                    123:                placeholders_count=marshal_binds(*bind, placeholders);
                    124: 
1.29      paf       125:        Temp_lang temp_lang(r, String::L_SQL);
1.18      paf       126:        const String& statement_string=r.process_to_string(statement);
1.29      paf       127:        const char* statement_cstr=
                    128:                statement_string.cstr(String::L_UNSPECIFIED, r.connection());
                    129:        Void_sql_event_handlers handlers(statement_string);
                    130:        r.connection()->query(
1.33      paf       131:                statement_cstr, 
                    132:                placeholders_count, placeholders,
1.39      misha     133:                0, SQL_NO_LIMIT,
1.22      paf       134:                handlers,
                    135:                statement_string);
1.34      paf       136: 
                    137:        if(bind)
                    138:                unmarshal_bind_updates(*bind, placeholders_count, placeholders);
1.1       parser    139: }
                    140: 
1.32      paf       141: static void _left_right(Request& r, MethodParams& params) {
                    142:        ssize_t sn=params.as_int(0, "n must be int", r);
                    143:        if(sn<0)
1.38      misha     144:                throw Exception(PARSER_RUNTIME,
1.32      paf       145:                        0, 
                    146:                        "n(%d) must be >=0", sn);
                    147: 
                    148:        // return nothing
                    149: }
                    150: 
                    151: static void _mid(Request& r, MethodParams& params) {
                    152:        ssize_t sbegin=params.as_int(0, "p must be int", r);
                    153:        if(sbegin<0)
1.38      misha     154:                throw Exception(PARSER_RUNTIME,
1.32      paf       155:                        0, 
                    156:                        "p(%d) must be >=0", sbegin);
                    157: 
                    158:        if(params.count()>1) {
                    159:                ssize_t sn=params.as_int(1, "n must be int", r);
                    160:                if(sn<0)
1.38      misha     161:                        throw Exception(PARSER_RUNTIME,
1.32      paf       162:                                0, 
                    163:                                "n(%d) must be >=0", sn);
                    164:        }
                    165: 
                    166:        // return nothing
                    167: }
                    168: 
1.1       parser    169: // constructor
                    170: 
1.29      paf       171: MVoid::MVoid(): Methoded("void") {
1.23      paf       172:        // ^void.length[] 
                    173:        add_native_method("length", Method::CT_DYNAMIC, _length, 0, 0);
1.24      paf       174: 
                    175:        // ^void.pos[substr]
1.41      misha     176:        // ^void.pos[substr](n)
1.40      misha     177:        add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 2);
1.23      paf       178: 
1.32      paf       179:        // ^void.int[]
1.9       parser    180:        // ^void.int(default)
1.8       parser    181:        add_native_method("int", Method::CT_DYNAMIC, _int, 0, 1);
1.1       parser    182: 
1.32      paf       183:        // ^void.double[]
1.9       parser    184:        // ^void.double(default)
1.8       parser    185:        add_native_method("double", Method::CT_DYNAMIC, _double, 0, 1);
1.1       parser    186: 
1.37      misha     187:        // ^void.bool[]
                    188:        // ^void.bool(default)
                    189:        add_native_method("bool", Method::CT_DYNAMIC, _bool, 0, 1);
                    190: 
1.41      misha     191:        // ^void:sql{query}
1.33      paf       192:        add_native_method("sql", Method::CT_STATIC, _sql, 1, 2);
1.32      paf       193: 
                    194:        // ^void.left() ^void.right()
                    195:        add_native_method("left", Method::CT_DYNAMIC, _left_right, 1, 1);
                    196:        add_native_method("right", Method::CT_DYNAMIC, _left_right, 1, 1);
                    197: 
                    198:        // ^void.mid(p;n)
                    199:        add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2);
1.1       parser    200: }

E-mail: