Init this object.
@param database The raw data database for this raw data table.
@param table The table this raw data table will supply data to.
@param The unique lookup key for this raw data table.
3585
public void init(MDatabase pDatabase, FieldList record, Object key)
    {
        super.init(pDatabase, record, key);
    }
486898
public void init(DatabaseOwner databaseOwner, String strDbName, int iDatabaseType, Map<String, Object> properties)
    {
        super.init(databaseOwner, strDbName, iDatabaseType, properties);

        this.setMasterSlave(RecordOwner.MASTER);      // This is in the client space (Don't execute Server Behaviors)
        
        this.setProperty(DBParams.MESSAGES_TO_REMOTE, DBConstants.FALSE);   // Sent by server version
        this.setProperty(DBParams.CREATE_REMOTE_FILTER, DBConstants.TRUE);  // Yes
        this.setProperty(DBParams.UPDATE_REMOTE_FILTER, DBConstants.FALSE); // Updated by server version
    }
697389
public void initializeStringTable() {
        
        stringTable = new byte[4096][];
        
        for (int i=0; i<256; i++) {
            stringTable[i] = new byte[1];
            stringTable[i][0] = (byte)i;
        }
        
        tableIndex = 258;
        bitsToGet = 9;
    }
779273
def init_db(self):
        '''
        
        '''
        with self.conn.transaction() as t:
            t.execute('''
            CREATE TABLE temporal (
                tuid     INTEGER,
                revision CHAR(12) NOT NULL,
                file     TEXT,
                line     INTEGER
            );''')

            t.execute('''
            CREATE TABLE annotations (
                revision       CHAR(12) NOT NULL,
                file           TEXT,
                annotation     TEXT,
                PRIMARY KEY(revision, file)
            );''')

            # Used in frontier updating
            t.execute('''
            CREATE TABLE latestFileMod (
                file           TEXT,
                revision       CHAR(12) NOT NULL,
                PRIMARY KEY(file)
            );''')

            t.execute("CREATE UNIQUE INDEX temporal_rev_file ON temporal(revision, file, line)")
        Log.note("Tables created successfully")
622271
@Override
    public void init() throws InitializationException {
        if (null == embedded || "true".equalsIgnoreCase(embedded)) {
            Log.warn("Audit4j Database Handler runs on embedded mode. See " + ErrorGuide.ERROR_URL
              + "embeddeddb for further details.");
            server = HSQLEmbededDBServer.getInstance();
            db_driver = server.getDriver();
            db_url = server.getNetworkProtocol() + ":file:audit4jdb";
            if (db_user == null) {
                db_user = Utils.EMBEDED_DB_USER;
            }
            if (db_password == null) {
                db_password = Utils.EMBEDED_DB_PASSWORD;
            }
            server.setUname(db_user);
            server.setPassword(db_password);
            server.start();
        }

        factory = ConnectionFactory.getInstance();
        factory.setDataSource(dataSource);
        factory.setDriver(getDb_driver());
        factory.setUrl(getDb_url());
        factory.setUser(getDb_user());
        factory.setPassword(getDb_password());

        factory.setDataSourceClass(db_datasourceClass);
        factory.setAutoCommit(db_pool_autoCommit);
        if (db_pool_connectionTimeout != null) {
            factory.setConnectionTimeout(db_pool_connectionTimeout);
        }
        if (db_pool_idleTimeout != null) {
            factory.setIdleTimeout(db_pool_idleTimeout);
        }
        if (db_pool_maximumPoolSize != null) {
            factory.setMaximumPoolSize(db_pool_maximumPoolSize);
        }
        if (db_pool_maxLifetime != null) {
            factory.setMaxLifetime(db_pool_maxLifetime);
        }
        if (db_pool_minimumIdle != null) {
            factory.setMinimumIdle(db_pool_minimumIdle);
        }

        if (getDb_connection_type() != null && getDb_connection_type().equals(POOLED_CONNECTION)) {
            factory.setConnectionType(ConnectionType.POOLED);
        } else if (getDb_connection_type() != null && getDb_connection_type().equals(JNDI_CONNECTION)) {
            factory.setConnectionType(ConnectionType.JNDI);
            factory.setJndiDataSource(getDb_jndi_datasource());
        } else {
            factory.setConnectionType(ConnectionType.SINGLE);
        }

        factory.init();

        try {
            getDaoForTable(default_table_name);
        } catch (HandlerException e) {
            throw new InitializationException("Unable to create tables", e);
        }

    }
44446
public void setTableIndex(TableIndex tableIndex) {
		this.tableIndex = tableIndex;
		if (tableIndex != null) {
			tableName = tableIndex.getTableName();
		} else {
			tableName = null;
		}
	}
603436
public void init(BaseDatabase database, Record record)
    {
        m_pTable = null;
        super.init(database, record);
        m_pTable = ((PhysicalDatabase)database).getPDatabase().getPTable(record, true);
        m_pTable.addPTableOwner(this);
    }
1269570
public function initialize(Table $table)
    {
        $this->table = $table;
        $this->table->isProcessing(true);
        $this->table->isServerSide(true);

        if (!is_null($this->ajax)) {
            $this->table->setAjax($this->ajax);
        }
    }
551611
public void init(Object parent, TableModel model)
    {
        super.init(parent, model);
        this.setModel(model);
    }
788708
protected void initializeBatch(String databaseName, String table)
      throws SQLException {
    this.insertStmtPrefix = createInsertStatementStr(databaseName, table);
    this.insertPstmtForFixedBatch =
        this.conn.prepareStatement(createPrepareStatementStr(this.batchSize));
    LOG.info(String.format("Initialized for %s insert " + this, (this.batchSize > 1) ? "batch" : ""));
  }
138294
static void init(String configName) {
		MAIN = DbKit.getConfig(configName).dbProFactory.getDbPro(configName); // new DbPro(configName);
		map.put(configName, MAIN);
	}
862842
protected void init(Source source) throws SQLException {

        if (source == null) {
            throw Util.nullArgument("source");
        }

        Transformer           transformer =
            JDBCSQLXML.getIdentityTransformer();
        StreamResult          result      = new StreamResult();
        ByteArrayOutputStream baos        = new ByteArrayOutputStream();
        GZIPOutputStream      gzos;

        try {
            gzos = new GZIPOutputStream(baos);
        } catch (IOException ex) {
            throw Exceptions.transformFailed(ex);
        }
        result.setOutputStream(gzos);

        try {
            transformer.transform(source, result);
        } catch (TransformerException ex) {
            throw Exceptions.transformFailed(ex);
        }

        try {
            gzos.close();
        } catch (IOException ex) {
            throw Exceptions.transformFailed(ex);
        }

        byte[] data = baos.toByteArray();

        setGZipData(data);
        setReadable(true);
        setWritable(false);
    }
1323142
private void init()
    {
        jdbcProperties = new Properties();
        dbcpProperties = new Properties();
        setFetchSize(0);
        this.setTestOnBorrow(true);
        this.setTestOnReturn(false);
        this.setTestWhileIdle(false);
        this.setLogAbandoned(false);
        this.setRemoveAbandoned(false);
    }
798731
def init_db(self):
        

        # database file
        db_path = self.get_data_file("data.sqlite")

        # comect and create cursor
        self.db = sqlite3.connect(db_path)
        self.cursor = self.db.cursor()

        # prep tables
        self.db_exec('''
            CREATE TABLE IF NOT EXISTS shortcuts (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                path TEXT NOT NULL,
                command TEXT NOT NULL
            )
            ''')
492804
public void init(RemoteTable tableRemote)
    {
        m_tableRemote = tableRemote;
        m_objCurrentPhysicalRecord = NONE;
        m_objCurrentLockedRecord = NONE;
        m_objCurrentCacheRecord = NONE;
        m_iCurrentLogicalPosition = -1;
        m_iPhysicalLastRecordPlusOne = -1;
    }
445174
public void initConnection()
    {
        try   {
            boolean bAutoCommit = true;
            if (DBConstants.FALSE.equalsIgnoreCase(this.getProperty(SQLParams.AUTO_COMMIT_PARAM)))
                bAutoCommit = false;
            m_JDBCConnection.setAutoCommit(bAutoCommit);
            DatabaseMetaData dma = m_JDBCConnection.getMetaData();
            String strDatabaseProductName = dma.getDatabaseProductName();
            Utility.getLogger().info("DB Name: " + strDatabaseProductName);
            this.setProperty(SQLParams.INTERNAL_DB_NAME, strDatabaseProductName);
            this.setupDatabaseProperties(); // If I haven't read the db properties, read them now!
            String strDateQuote = this.getProperty(SQLParams.SQL_DATE_QUOTE);
            if ((strDateQuote != null) && (strDateQuote.length() > 0))
                DateTimeField.setSQLQuote(strDateQuote.charAt(0));
            Converter.initGlobals();
            String strFormat = this.getProperty(SQLParams.SQL_DATE_FORMAT);
            if (strFormat != null)
                Converter.gDateSqlFormat = new java.text.SimpleDateFormat(strFormat);
            strFormat = this.getProperty(SQLParams.SQL_TIME_FORMAT);
            if (strFormat != null)
                Converter.gTimeSqlFormat = new java.text.SimpleDateFormat(strFormat);
            strFormat = this.getProperty(SQLParams.SQL_DATETIME_FORMAT);
            if (strFormat != null)
                Converter.gDateTimeSqlFormat = new java.text.SimpleDateFormat(strFormat);
            if (DBConstants.TRUE.equals(this.getProperty(SQLParams.SHARE_JDBC_CONNECTION)))
                m_sharedConnection = m_JDBCConnection;  // HACK - Only one DB open at a time (pointbase)!
            Utility.getLogger().info("Connected to db: " + this.getDatabaseName(true));
        }
        catch (SQLException ex)
        {
            // Ignore errors to these non-essential calls;  // Probably "DB Not found"
        }
    }
642077
def init_db():
    """"""
    with closing(connect_db()) as db:
        db.cursor().execute("DROP TABLE IF EXISTS entries")
        db.cursor().execute(
            """
            CREATE TABLE entries (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                text TEXT NOT NULL
            )
            """
        )
        db.commit()